#include <bits/stdc++.h>

using namespace std;

//varianta 3 - Euler + Rmq

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

const int nmax = 100005;


int level[nmax];
int first[nmax];
int dp[nmax * 2][18];
vector <int> son[nmax];

int k;

void dfs(int nod, int lvl)
{
    level[nod] = lvl;
    first[nod] = k;
    dp[k][0] = nod;
    k ++;

    for (auto el : son[nod])
    {
        dfs(el, lvl + 1);
        dp[k ++][0] = nod;
    }
}

int main()
{
    int n, m;
     f >> n >> m;
    for (int i = 1; i < n; ++ i)
    {
        int x;
        f >> x;
        son[x].push_back(i + 1);
    }
    dfs(1, 0);
    for (int j = 1; (1 << j) <= k; ++ j)
        for (int i = 0; i + (1 << j) <= k; ++ i)
            if (level[dp[i][j - 1]] < level[dp[i + (1 << (j - 1))][j - 1]])
                dp[i][j] = dp[i][j - 1];
            else
                dp[i][j] = dp[i + (1 << (j - 1))][j - 1];

    for (int i = 1; i <= m; ++ i)
    {
        int a, b;
        f >> a >> b;
        a = first[a];
        b = first[b];
        if (a > b)
            swap(a, b);
        int d = b - a + 1;
        int l = (int) log2(d);
        assert(l < 20);
        assert(a + d - (1 << l) < 2 * nmax);
        if (level[dp[a][l]] < level[dp[a + d - (1 << l)][l]])
            g << dp[a][l];
        else
            g << dp[a + d - (1 << l)][l];
        g << '\n';
    }
}