/// [A][M][C][B][N] ///
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const char sp = ' ', nl = '\n';
using namespace std;
ifstream fin("lca.in");
ofstream fout("lca.out");

// Tree
const int nmax = 1e5;
int t[nmax + 1]{ 0 };
vector<int> g[nmax + 1];

// Euler Tour
int viz[nmax + 1]{ 0 };
int depth[nmax + 1]{ 0 };
int pos[nmax + 1]{ 0 };
vector<int> euler;

void tour(int u) {
    viz[u] = 1;
    depth[u] = depth[t[u]] + 1;
    pos[u] = euler.size();
    euler.push_back(u);
    for (auto& v : g[u]) {
        if (!viz[v]) {
            tour(v);
            euler.push_back(u);
        }
    }
}

// Range Minimum Querry
int rmq[2 * nmax + 1][18]{ 0 }, lg2[2 * nmax + 1]{ 0 };

void build() {
    int n = euler.size();
    for (int i = 2; i <= n; ++i) {
        lg2[i] = lg2[i / 2] + 1;
    }
    for (int i = 0; i < n; ++i) {
        rmq[i][0] = euler[i];
    }
    for (int j = 1; (1 << j) <= n; ++j) {
        for (int i = 0; i + (1 << (j - 1)) - 1 < n; ++i) {
            if (depth[rmq[i][j - 1]] < depth[rmq[i + (1 << (j - 1))][j - 1]]) {
                rmq[i][j] = rmq[i][j - 1];
            }
            else {
                rmq[i][j] = rmq[i + (1 << (j - 1))][j - 1];
            }
        }
    }
}

int querry(int i, int j) {
    int k = lg2[j - i + 1];
    if (depth[rmq[i][k]] < depth[rmq[j - (1 << k) + 1][k]]) {
        return rmq[i][k];
    }
    else {
        return rmq[j - (1 << k) + 1][k];
    }
}

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    int n, m;
    fin >> n >> m;
    for (int i = 2; i <= n; ++i) {
        fin >> t[i];
        g[t[i]].push_back(i);
    }
    tour(1);
    build();
    while (m--) {
        int u, v;
        fin >> u >> v;
        u = pos[u], v = pos[v];
        if (u > v) {
            swap(u, v);
        }
        fout << querry(u, v) << nl;
    }
}