#include <iostream>
#include <fstream>
#include <vector>
using namespace std;

ifstream f ("lca.in");
ofstream g ("lca.out");

int viz[100005] , euler[1000005] , x , n , q , k , niv[1000005] , first[100005] , neul , arb[1000005] , minim  , y , nr;

vector <int> v[100005];



void build(int nod , int left , int right)
{
    if(left == right)
    {
        arb[nod] = left;
        return ;
    }

    int mid = (left + right) / 2;

    build( 2 * nod , left , mid);
    build( 2 * nod + 1 , mid + 1 , right);

    if(niv[arb[2 * nod]] <= niv[arb[2 * nod + 1]])
        arb[nod] = arb[2 * nod];
    else
        arb[nod] = arb[2 * nod + 1];
}

void querry(int nod , int left , int right , int qleft , int qright)
{
    if( left >= qleft && right <= qright)
    {
        if(niv[arb[nod]] <= minim)
        {
            minim = niv[arb[nod]];
            nr = euler[arb[nod]];
        }
        return ;
    }
    int mid = (left + right) / 2;

    if(qleft <= mid)
        querry(2 * nod , left , mid , qleft , qright);
    if(qright > mid)
        querry(2 * nod + 1 , mid + 1 , right , qleft , qright);
}


void dfs (int nod , int nivel)
{
    euler[++k] = nod;
    niv[k] = nivel;
    first[nod] = k;
    for (int i = 0 ; i < v[nod].size () ; i++)
    {
        int vecin = v[nod][i];
        dfs (vecin , nivel + 1);
        euler[++k] = nod;
        niv[k] = nivel;

    }
}

int lca(int x , int y)
{
    int st = first[x];
    int dr = first[y];
    if(st > dr)
        swap(st , dr);
    minim = 2e9;
    nr = 0;
    querry( 1 , 1 , k , st , dr);
    return nr;

}

int main()
{
    f >> n >> q;

    for (int i = 2 ; i <= n ; i++)
    {
        f >> x;
        v[x].push_back (i);
    }

    dfs (1 , 0);
    neul = k;

    build (1 , 1 ,  neul);

    for (int i = 1 ; i <= q ; i++)
    {
        f >> x >> y;
        g << lca (x , y) << '\n';
    }



    return 0;
}