/*
 * O(NlogN + Q)
 */
#include <fstream>
#include <iostream>
#include <vector>
using namespace std;

const int MAX_LOG = 19;
const int MAX_N = 100005;

int N, Q;
vector<int> arbore[MAX_N];

struct RmqItem
{
    int nod;
    int nvl;
};

int p_curent;
int p_start[2 * MAX_N];
RmqItem rmq[MAX_LOG][2 * MAX_N];
int max_bit[2 * MAX_N];

void dfs(int nod, int nvl = 1)
{
    rmq[0][++p_curent] = {nod, nvl};
    p_start[nod] = p_curent;
    for (int fiu : arbore[nod])
    {
        dfs(fiu, nvl + 1);
        rmq[0][++p_curent] = {nod, nvl};
    }
}

void calculeaza_rmq()
{
    for (int p = 1; p < MAX_LOG; ++p)
    {
        for (int i = 1; i <= p_curent; ++i)
        {
            RmqItem st = rmq[p - 1][i];
            if (i + (1 << (p - 1)) <= p_curent)
            {
                RmqItem dr = rmq[p - 1][i + (1 << (p - 1))];
                rmq[p][i] = st.nvl < dr.nvl ? st : dr;
            }
            else
            {
                rmq[p][i] = st;
            }
        }
    }
}

void calculeaza_max_bit()
{
    // calculeaza max_bit[i] cea mai mare putere a lui 2 <= i
    max_bit[1] = 0;
    for (int i = 2; i <= p_curent; ++i)
    {
        max_bit[i] = max_bit[i / 2] + 1;
    }
}

int lca(int x, int y)
{
    int pos_x = p_start[x];
    int pos_y = p_start[y];
    if (pos_x > pos_y)
    {
        swap(pos_x, pos_y);
    }
    int p = max_bit[pos_y - pos_x + 1];
    RmqItem st = rmq[p][pos_x];
    RmqItem dr = rmq[p][pos_y - (1 << p) + 1];
    if (st.nvl < dr.nvl)
    {
        return st.nod;
    }
    else
    {
        return dr.nod;
    }
}

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

    fin >> N >> Q;
    for (int nod = 2; nod <= N; ++nod)
    {
        int parinte;
        fin >> parinte;
        arbore[parinte].push_back(nod);
    }

    p_curent = 0;
    dfs(1);
    calculeaza_rmq();
    calculeaza_max_bit();

    while (Q--)
    {
        int x, y;
        fin >> x >> y;
        fout << lca(x, y) << "\n";
    }

    return 0;
}