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

using namespace std;

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

int n, m;
long long int first[2*NMAX], logg[2*NMAX], dp[2*NMAX][20];
vector <int> G[NMAX];
vector < pair <int, int> > euler;

int LCA(int x, int y);
void DFS(int nod, int nivel);
void RMQ();
void logaritm();

int main()
{
    int x, y;
    fin >> n >> m;
    for (int i = 2; i <= n; i++)
    {
        fin >> x;
        G[x].push_back(i);
    }
    DFS(1, 0);
    logaritm();
    RMQ();
    for (int i = 1; i <= m; i++)
    {
        fin >> x >> y;
        fout << LCA(x, y) << '\n';
    }
    return 0;
}

void DFS(int nod, int nivel)
{
    first[nod] = euler.size();
    euler.push_back({nod, nivel});

    for (auto vecin : G[nod])
    {
        DFS(vecin, nivel+1);
        euler.push_back({nod, nivel});
    }
}

int LCA(int x, int y)
{
    x = first[x];
    y = first[y];
    if (x > y)
        swap(x, y);
    int lg = y - x + 1;
    lg = logg[lg];
    int I1 = dp[x][lg];
    int I2 = dp[y - (1<<lg) + 1][lg];
    if (euler[I1].second < euler[I2].second)
        return euler[I1].first;
    return euler[I2].first;
}

void RMQ()
{
    int len = euler.size();
    for (int i = 0; i < len; i++)
        dp[i][0] = i;

    for (int j = 1; (1 << j) <= len; j++)
        for (int i = 0; i + (1 << j) <= len; i++)
        {
            int l = dp[i][j-1];
            int r = dp[i+(1<<(j-1))][j-1];
            if (euler[l].second < euler[r].second)
                dp[i][j] = l;
            else
                dp[i][j] = r;
        }
}

void logaritm()
{
    int len = euler.size();
    logg[1] = 0;
    for (int i = 2; i <= len; i++)
        logg[i] = logg[i/2] + 1;
}