#include<fstream>
#include<vector>
#include<deque>

using namespace std;
typedef int var;

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

#define MAXN 100001

vector<var> G[MAXN];
deque<var> Path[MAXN];
var PathP[MAXN], Heavy[MAXN], Depth[MAXN], WhatPath[MAXN], WhatPos[MAXN];
var paths;

void dfs(var node, var depth) {
    Depth[node] = depth;
    Heavy[node] = 1;
    var M = -1, N;
    for(auto vec : G[node]) {
        if(Depth[vec] == 0) {
            dfs(vec, depth+1);
            Heavy[node] += Heavy[vec];
            PathP[WhatPath[vec]] = node;
            if(M < Heavy[vec]) {
                M = Heavy[vec];
                N = WhatPath[vec];
            }
        }
    }
    if(M == -1) {
        WhatPath[node] = ++paths;
    } else {
        WhatPath[node] = N;
    }
    Path[WhatPath[node]].push_front(node);
}

var lca(var a, var b) {
    var p1 = WhatPath[a];
    var p2 = WhatPath[b];
    while(p1 != p2) {
        if(Depth[PathP[p1]] > Depth[PathP[p2]]) {
            a = PathP[p1];
            p1 = WhatPath[a];

        } else {
            b = PathP[p2];
            p2 = WhatPath[b];
        }
    }

    return (Depth[a] < Depth[b]) ? a : b;

}



int main() {
    var n, m, a, b;
    fin>>n>>m;
    for(var i=2; i<=n; i++) {
        fin>>a;
        G[a].push_back(i);
        G[i].push_back(a);
    }
    dfs(1, 1);
    PathP[WhatPath[1]] = 0;

    while(m--) {
        fin>>a>>b;
        fout<<lca(a, b)<<'\n';
    }
}