#include <bits/stdc++.h>
#define NMAX 100005

using namespace std;

ifstream fin( "lca.in" );
ofstream fout( "lca.out" );

int N;
int nrq;

vector <int> Ad[NMAX];

int M;
int euler[2*NMAX];
int level[NMAX];
int poz[NMAX];

int rmq[20][NMAX];
int lg[NMAX];

void DFS( int nod, int lvl, int parent )
{
    int i, w;

    euler[++M] = nod;

    if ( !poz[nod] )
    {
        level[nod] = lvl;
        poz[nod] = M;
    }

    for ( i = 0; i < Ad[nod].size(); ++i )
    {
        w = Ad[nod][i];

        if ( w != parent )
        {
            DFS( w, lvl + 1, nod );

            euler[++M] = nod;
        }
    }
}

void gen_euler()
{
    DFS( 1, 0, 0 );
}

void RMQ()
{
    int i, j, a, b;

    for ( i = 1; i <= M; ++i )
         rmq[0][i] = euler[i];

    lg[2] = 1;
    for ( i = 3; i <= N; ++i )
         lg[i] = lg[i/2] + 1;

    for ( i = 1; ( 1 << i ) <= M; ++i )
    {
        for ( j = 1; j + ( 1 << i ) + 1 <= M; ++j )
        {
            a = rmq[ i - 1 ][ j ];
            b = rmq[ i - 1 ][ j + ( 1 << ( i - 1 ) ) - 1 ];

            if ( level[a] < level[b] )
                rmq[i][j] = a;
            else rmq[i][j] = b;
        }
    }
}

int LCA( int x, int y )
{
    int a, b;
    int logg, sol;

    a = poz[x];
    b = poz[y];

    if ( a > b ) swap( a, b );

    logg = lg[b-a+1];
    sol = rmq[logg][a];

    if ( level[ rmq[logg][a] ] > level[ rmq[logg][ b - ( 1 << logg ) + 1 ] ] )
        sol = rmq[logg][ b - ( 1 << logg ) + 1 ];

    return sol;
}

void read()
{
    int i, x, y;

    fin >> N >> nrq;

    for ( i = 2; i <= N; ++i )
    {
        fin >> x;

        Ad[i].push_back( x );
        Ad[x].push_back( i );
    }

    gen_euler();
    RMQ();

    for ( i = 1; i <= nrq; ++i )
    {
        fin >> x >> y;

        fout << LCA( x, y ) << '\n';
    }

    fin.close();
}

int main()
{
    read();

    fout.close();

    return 0;
}