#include<fstream>
#include<vector>
#include<algorithm>
#define EMAX 200010
#define ARBMAX 600010
#define NMAX 100010

using namespace std;

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

int n, T, lca, niv_lca;
int p_ap[EMAX], val[NMAX], P[EMAX], arb[ARBMAX], nod_cautat[ARBMAX];

vector<int> v[NMAX];

void Citeste()
{
    int i, x;

    f>>n>>T;

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

void Euler(int nod, int niv)
{
    int i;

    P[++P[0]]=nod; p_ap[nod]=P[0]; val[nod]=niv;

    for (i=0; i<v[nod].size(); ++i)
    {
        Euler(v[nod][i], niv+1);
        P[++P[0]]=nod;
    }

}

void AdI(int st, int dr, int nod)
{
    int mij=(st+dr)/2;

    if (st==dr)
    {
        arb[nod]=val[P[st]];
        nod_cautat[nod]=P[st];
    }
    else
    {
        AdI(st, mij, 2*nod);
        AdI(mij+1, dr, 2*nod+1);

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

void LCA(int st, int dr, int u, int w, int nod)
{
    int mij=(st+dr)/2;

    if (st>=u && dr<=w)
    {
        if (niv_lca>arb[nod])
        {
            niv_lca=arb[nod];
            lca=nod_cautat[nod];
        }
    }
    else
    {
        if ( (u>=st && u<=mij) || (w>=st && w<=mij) || (st>=u && mij<=w)) LCA(st, mij, u, w, nod*2);
        if ( (u>=mij+1 && u<=dr) || (w>=mij+1 && w<=dr) || (mij+1>=u && dr<=w)) LCA(mij+1, dr, u, w, nod*2+1);
    }
}

void Solve()
{
    int x, y, u, w;

    while (T--)
    {
        f>>x>>y;

        u=min(p_ap[x], p_ap[y]);
        w=max(p_ap[x], p_ap[y]);

        niv_lca=n; lca=P[0]+1;

        LCA(1, P[0], u, w, 1);

        g<<lca<<"\n";
    }
}

int main()
{
    Citeste();

    Euler(1, 0);

    AdI(1, P[0], 1);

    Solve();

    f.close();
    g.close();
    return 0;
}