#include <bits/stdc++.h>

using namespace std;

template <class T>
struct RMQ {
    const T kInf = numeric_limits<T>::max();
    vector<vector<T>> rmq;

    void Build(const vector<T>& V) {
        int n = V.size(), on = 1, depth = 1;
        while (on < n) on *= 2, ++depth;
        rmq.assign(depth, V);

        for (int i = 0; i < depth - 1; ++i)
            for (int j = 0; j < n; ++j) {
                rmq[i + 1][j] = min(rmq[i][j],
                        rmq[i][min(n - 1, j + (1 << i))]);
            }
    }

    T Query(int a, int b) {
        if (b <= a) return kInf;
        int dep = 31 - __builtin_clz(b - a); // log(b - a)
        return min(rmq[dep][a], rmq[dep][b - (1 << dep)]);
    }
};

struct LCA {
    vector<int> enter, depth;
    vector<vector<int>> G;
    vector<pair<int, int>> linear;
    RMQ<pair<int, int>> rmq;
    int timer = 0;

    LCA(int n) : enter(n, -1), depth(n), G(n), linear(2 * n) {}

    void dfs(int node, int dep) {
        linear[timer] = {dep, node};
        enter[node] = timer++;
        depth[node] = dep;

        for (auto vec : G[node])
            if (enter[vec] == -1) {
                dfs(vec, dep + 1);
                linear[timer++] = {dep, node};
            }
    }

    void AddEdge(int a, int b) {
        G[a].push_back(b);
        G[b].push_back(a);
    }

    void Build(int root) {
        dfs(root, 0);
        rmq.Build(linear);
    }

    int Query(int a, int b) {
        a = enter[a], b = enter[b];
        return rmq.Query(min(a, b), max(a, b) + 1).second;
    }

    int Distance(int a, int b) {
        return depth[a] + depth[b] - 2 * depth[Query(a, b)];
    }
};

int main() {
    ifstream cin("lca.in");
    ofstream cout("lca.out");

    int n, q; cin >> n >> q;
    LCA lca(n);
    for (int i = 1; i < n; ++i) {
        int par; cin >> par;
        lca.AddEdge(par - 1, i);
    }
    lca.Build(0);

    while (q--) {
        int a, b; cin >> a >> b;
        cout << lca.Query(a - 1, b - 1) + 1 << '\n';
    }
    return 0;
}