#include <bits/stdc++.h>
#define Nmax 100005
#define Lmax 20

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

int n, m;
int rmq[Nmax * Lmax][Lmax], lvl[Nmax], first[Nmax];
vector <int> G[Nmax], euler;

void read()
{
    f >> n >> m;

    int x;
    for (int i = 2; i <= n; ++i) {
        f >> x;
        G[x].push_back(i);
    }
}

void dfs(int node, int level)
{
    euler.push_back(node);

    int k = euler.size() - 1;
    lvl[node] = level;
    first[node] = k;
    for (int i = 0; i < G[node].size(); ++i) {
        dfs(G[node][i], level + 1);
        euler.push_back(node);
    }
}

void constructTree()
{
    int n = euler.size() - 1;
    for (int i = 1; i <= n; ++i)
        rmq[i][0] = euler[i];

    for (int j = 1; 1 << j <= n; ++j) {
        for (int i = 1; i + (1 << j) - 1 <= n; ++i) {
            if (lvl[rmq[i][j - 1]] < lvl[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 ask(int ls, int rs)
{
    int k = floor(log2(rs - ls + 1));
    if (lvl[rmq[ls][k]] < lvl[rmq[rs - (1 << k) + 1][k]])
        return rmq[ls][k];
    return rmq[rs - (1 << k) + 1][k];
}

void solve()
{
    constructTree();
    int x, y;
    for (int i = 0; i < m; ++i) {
        f >> x >> y;
        if (first[x] > first[y])
            swap(x, y);
        g << ask(first[x], first[y]) << "\n";
    }
}

int main()
{
    read();
    euler.push_back(-1);
    dfs(1, 0);
    solve();
    return 0;
}