#include <iostream>
#include <iomanip>
#include <fstream>

#include <algorithm>
#include <bitset>
#include <deque>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>

#if __cplusplus > 199711L
#include <unordered_map>
#include <unordered_set>
#endif

#include <cstdio>
#include <ctime>
#include <cmath>
#include <cstring>
#include <cstdlib>

using namespace std;

typedef long long int64;

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

const int NMAX = 100010, inf = 0x3f3f3f3f;

int N, M;
int tree[8 * NMAX], first[NMAX];
vector<int> G[NMAX], nodes, level;

void DF(const int node, const int lvl)
{
    nodes.push_back(node);
    level.push_back(lvl);
    first[node] = nodes.size() - 1;

    for (size_t it = 0; it < G[node].size(); ++it)
    {
        DF(G[node][it], lvl + 1);

        nodes.push_back(node);
        level.push_back(lvl);
    }
}

void build(const int node, const int left, const int right)
{
    if (left == right)
    {
        tree[node] = left;
        return;
    }

    int div = (left + right) >> 1;
    build(node * 2, left, div);
    build(node * 2 + 1, div + 1, right);

    if (level[tree[node * 2]] > level[tree[node * 2 + 1]])
        tree[node] = tree[node * 2 + 1];
    else tree[node] = tree[node * 2];
}

int query(const int node, const int left, const int right, const int qleft, const int qright)
{
    if (left >= qleft && qright >= right)
        return tree[node];

    int ret = inf, div = (right + left) >> 1, q;

    if (qleft <= div) ret = query(node * 2, left, div, qleft, qright);
    if (qright > div)
    {
        q = query(node * 2 + 1, div + 1, right, qleft, qright);
        if (ret == inf || level[ret] > level[q])
            ret = q;
    }

    return ret;
}

int main()
{
    int i, x, y;

    fin >> N >> M;

    for (i = 2; i <= N; ++i)
    {
        fin >> x;
        G[x].push_back(i);
    }

    nodes.push_back(0), level.push_back(0);
    DF(1, 0);
    build(1, 1, nodes.size() - 1);

    while(M--)
    {
        fin >> x >> y;
        if (first[x] > first[y]) swap(x, y);

        fout << nodes[query(1, 1, nodes.size() - 1, first[x], first[y])] << '\n';
    }

    fin.close();
    fout.close();
    return 0;
}