#include <iostream>
#include <fstream>
#include <vector>
#include <climits>
#include <queue>
#include <cmath>

using namespace std;
ifstream in("lca.in");
ofstream out("lca.out");

const int NMax = 1e5 + 5;
const int inf = 1e9;

// solutie cu precalculare O(NlogN) si O(1) pe query

int N,M,nrEuler;
int euler[2*NMax],poz[NMax],depth[NMax],
    lg[2*NMax],mn[2*NMax][20];

vector<int> v[NMax];
// euler - vector ce va retine o parcurgere euler a arborelui dat
// poz[i] - pozitia ocupata in parcurgere de prima aparitie a nodului i
// depth[i] - adancimea nodului i in arbore
// lg[i] - cel mai mare exponent e, astfel incat 2^e <= i
// mn[i][j] - nodul cu adancimea minima din intervalul [i,i + 2^j - 1] din parcurgerea euler
//            (un range minimum query)

void doEuler(int,int);
// functia doEuler genereaza parcurgerea euler a arborelui printr-un dfs

int main() {
    in>>N>>M;

    for (int i=2;i<=N;++i) {
        int dad;
        in>>dad;
        v[dad].push_back(i);
    }

    doEuler(1,1);

    lg[1] = 0;
    mn[1][0] = euler[1];
    for (int i=2;i<=nrEuler;++i) {
        lg[i] = lg[i/2] + 1;
        mn[i][0] = euler[i];
    }

    // se formeaza mn
    for (int p=1;(1<<p) <= nrEuler;++p) {
        for (int i=1;i + (1<<p) - 1 <= nrEuler;++i) {
            int nod1 = mn[i][p-1],
                nod2 = mn[i + (1<<(p-1))][p-1];
            if (depth[nod1] < depth[nod2]) {
                mn[i][p] = nod1;
            }
            else {
                mn[i][p] = nod2;
            }
        }
    }

    while (M--) {
        int a,b;
        in>>a>>b;
        if (poz[a]>poz[b]) {
            swap(a,b);
        }

        int i = poz[a], j = poz[b],
            p = lg[j-i+1],
            nod1 = mn[i][p],
            nod2 = mn[j - (1<<p) + 1][p];

        int ans;
        if (depth[nod1] < depth[nod2]) {
            ans = nod1;
        }
        else {
            ans = nod2;
        }

        out<<ans<<'\n';
    }

    return 0;
}

void doEuler(int x,int d) {
    euler[++nrEuler] = x;
    poz[x] = nrEuler;
    depth[x] = d;

    int lim = v[x].size();
    for (int i=0;i<lim;++i) {
        int son = v[x][i];
        doEuler(son,d+1);
        euler[++nrEuler] = x;
    }
}