#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <cassert>

using namespace std;

vector<int> lg2;
template<typename T>
class rmq
{
public:
    rmq(const vector<T> &vec)
    {
        v = vec;
        for(int i = 0; (1 << i) < v.size(); ++i)
            mn.push_back(vector<T>(v.size()));
        if(v.size() > lg2.size())
            Setlg2();
        Update();
    }
    T QueryVal(int st, int dr)
    {
        int partSize = lg2[dr - st + 1];
        int x = mn[partSize][st], y = mn[partSize][dr - (1 << partSize) + 1];
        if(v[x] < v[y])
            return v[x];
        return v[y];
    }
    T QueryInd(int st, int dr)
    {
        int partSize = lg2[dr - st + 1];
        int x = mn[partSize][st], y = mn[partSize][dr - (1 << partSize) + 1];
        if(v[x] < v[y])
            return x;
        return y;
    }
    void SetV(const vector<T> &vec)
    {
        assert(vec.size() == v.size());
        Update();
    }
private:
    void Update()
    {
        for(int i = 0; i < v.size(); ++i)
            mn[0][i] = i;
        int x, y;
        for(int i = 1; (1 << i) < v.size(); ++i)
            for(int j = 0; j + (1 << (i - 1)) < v.size(); ++j)
            {
                x = mn[i-1][j], y = mn[i-1][j + (1 << (i - 1))];
                if(v[x] < v[y])
                    mn[i][j] = x;
                else
                    mn[i][j] = y;
            }
    }
    void Setlg2()
    {
        lg2.resize(v.size());
        lg2[1] = 0;
        for(int i = 2; i < v.size(); ++i)
            lg2[i] = lg2[i/2] + 1;
    }
    vector<T> v;
    vector<vector<T> > mn;
};

//1 - indexed
class LCA
{
public:
    LCA(const vector<int> &father)
    {
        vector<vector<int> > vecini(father.size());
        for(int i = 1; i < father.size(); ++i)
        {
            if(father[i] == 0)
                continue;
            vecini[i].push_back(father[i]);
            vecini[father[i]].push_back(i);
        }
        Build(vecini);
    }
    LCA(const vector<vector<int> > &vecini)
    {
        Build(vecini);
    }
    void Build(const vector<vector<int> > &vecini)
    {
        vector<int> nivel(1);
        euler.resize(1);
        firstAp.resize(vecini.size());
        DFS(1, 1, vecini, euler, nivel, 0);
        r = new rmq<int>(nivel);
    }
    int GetLCA(int x, int y)
    {
        int a = firstAp[x], b = firstAp[y];
        if(a > b)
            swap(a, b);
        return euler[r->QueryInd(a, b)];
    }
private:
    void DFS(int current, int father, const vector<vector<int> > &vecini, vector<int> &euler, vector<int> &nivel, int niv)
    {
        firstAp[current] = nivel.size();
        nivel.push_back(niv);
        euler.push_back(current);
        for(auto c:vecini[current])
            if(c != father)
            {
                DFS(c, current, vecini, euler, nivel, niv+1);
                nivel.push_back(niv);
                euler.push_back(current);
            }
    }
    vector<int> euler;
    vector<int> firstAp;
    rmq<int> * r;
};

int main()
{
    ifstream in("lca.in");
    ofstream out("lca.out");
    int n, m;
    in >> n >> m;
    vector<int> father(n+1);
    for(int i = 2; i <= n; ++i)
        in >> father[i];
    LCA arb(father);
    int x, y;
    while(m--)
    {
        in >> x >> y;
        out << arb.GetLCA(x, y) << "\n";
    }
    in.close();
    out.close();
    return 0;
}