#include <iostream>
#include <fstream>
#include <vector>
#define VMAX 100000

using namespace std;

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

int V, queries, x;
vector <int> adj[VMAX];
int euler[VMAX << 1], height[VMAX << 1], first[VMAX], lg2[VMAX << 2 + 1];
int rmq[VMAX << 2][20];
int contor = -1;

void DFS(int nod, int lvl)
{
    ++contor;
    euler[contor] = nod;
    height[contor] = lvl;
    first[nod] = contor;

    for (auto w:adj[nod])
    {
        DFS(w, lvl + 1);
        ++contor;
        euler[contor] = nod;
        height[contor] = lvl;
    }
}

void preprocess()
{
    for (int i = 2; i <= contor; ++i)
        lg2[i] = lg2[i >> 1] + 1;

    for (int i = 0; i < contor; ++i)
        rmq[i][0] = i;

    for (int j = 1; (1 << j) <= contor; ++j)
        for (int i = 0; i + (1 << j) - 1 < contor; ++i)
        rmq[i][j] = height[rmq[i][j - 1]] < height[rmq[i + (1 << (j - 1))][j - 1]] ?
                        rmq[i][j - 1] : rmq[i + (1 << (j - 1))][j - 1];
}

int answerQuery(int x, int y)
{
    int a = first[x], b = first[y];

    if (a > b)
    {
        int aux;
        aux = a, a = b, b = aux;
    }

    int k = lg2[b - a + 1];
    int sol = height[rmq[a][k]] < height[rmq[b - (1 << k) + 1][k]] ?
              rmq[a][k] : rmq[b - (1 << k) + 1][k];


    return euler[sol];
}

int main()
{
    fin >> V >> queries;

    for (int i = 1; i < V; ++i)
    {
        fin >> x;
        adj[x - 1].push_back(i);
    }

    DFS(0, 0);

    preprocess();

    int a, b;

    while (queries--)
    {
        fin >> a >> b;
        fout << answerQuery(a - 1, b - 1) + 1 << '\n';
    }

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