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

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

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

vector <int> v[100005];


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

    build (2 * nod , left , mij);
    build (2 * nod + 1 , mij + 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 ql , int qr)
{
    if (ql <= left && right <= qr)
    {
        if (niv[arb[nod]] <= minim)
        {
            minim = niv[arb[nod]];
            nr = euler[arb[nod]];
        }
        return;
    }
    int mij = (left + right) / 2;
    if (ql <= mij)
        querry (2 * nod , left , mij , ql , qr);
    if (qr > mij)
        querry (2 * nod + 1 , mij + 1 , right , ql , qr);
}

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;
}