#include <fstream>
using namespace std;
ifstream f("lca.in");
ofstream g("lca.out");

typedef struct NOD {
    int inf;
    struct NOD* next;
} NOD;

typedef struct {
    NOD* prim;
} LIST;


#define NMAX 100005
LIST T[NMAX];
int n, m;
int u, v;
int P[NMAX], A[4*NMAX], B[4*NMAX];
int nr = 0;
int ADI[1000000]; // Arbore de Intervale

void insereaza(LIST* L, int x)
{
    NOD* p=new(NOD);
    p->inf = x;
    p->next = L->prim;
    L->prim = p;
}

void DFS(LIST T[], int x, int p)
{
    nr++;
    P[x] = nr;
    A[nr] = p;
    B[nr] = x;
    for (NOD* q=T[x].prim; q; q=q->next){
        DFS(T,q->inf,p+1);
        nr++;
        A[nr] = p;
        B[nr] = x;
    }
}

int minim(int l, int r)
{
    if (l>r) swap(l,r);
    int p=l;
    for (int i=l+1; i<=r; i++)
        if (A[p]>A[i]) p = i;
    return B[p];
}

void creareADI(int p, int l, int r)
{
    if (l==r) {ADI[p] = l; return; }
    int t = (l+r)/2;
    creareADI(2*p+1,l,t);
    creareADI(2*p+2,t+1,r);
    if (A[ADI[2*p+1]] < A[ADI[2*p+2]]) ADI[p] = ADI[2*p+1]; else ADI[p] = ADI[2*p+2];
    //ADI[p] = min(ADI[2*p+1],ADI[2*p+2]);
}

int minimADI(int p, int l, int r, int pi, int pf)
{
    if (l==pi && r==pf) return ADI[p];
    int t=(l+r)/2;
    if (pf<=t) return minimADI(2*p+1,l,t,pi,pf);
    if (pi>t) return minimADI(2*p+2,t+1,r,pi,pf);
    if (A[minimADI(2*p+1,l,t,pi,t)] < A[minimADI(2*p+2,t+1,r,t+1,pf)])
        return minimADI(2*p+1,l,t,pi,t);
        else return minimADI(2*p+2,t+1,r,t+1,pf);
    //return min(minimADI(2*p+1,l,t,pi,t), minimADI(2*p+2,t+1,r,t+1,pf));
}

int main()
{
    int x;
    f >> n >> m;
    for (int i=2; i<=n; i++){
        f >> x;
        insereaza (&T[x],i);
    }
    DFS(T,1,0);
    creareADI(0,1,nr);
    for (;m--;){
        f >> u >> v;
        u = P[u];
        v = P[v];
        if (u>v) swap(u,v);
        g << B[minimADI(0,1,nr,u,v)] << '\n';
        //g << minim(u,v) << '\n';
    }
    return 0;
}