/**
Se da un arbore sub forma:
n (# noduri), m (# muchii)
x_1 y_1 // Muchii
...
x_m y_m
q (# query uri)
a_1 b_1 // cout << lca(a_1, b_1)
...
a_q b_q
**/

#include <bits/stdc++.h>

using namespace std;

const int NMAX = 1e5 + 7;
const int LMAX = 18;
vector<int> g[NMAX];

int root = 1;

vector<int> euler;
int inveuler[NMAX];
int depth[NMAX];

void liniarize(int node, int father, int cnt_depth) {
    depth[node] = cnt_depth; // Partea pentru Depth

    // Partea pentru liniarizare
    euler.push_back(node);
    for(auto son : g[node]) {
        if(son == father) continue;
        liniarize(son, node, cnt_depth + 1);
        euler.push_back(node);
    }
}

// pair<int, int> rmq[LMAX][(1 << LMAX)];
int rmq[LMAX][(1 << LMAX)];

// Comparator de la pair
/* bool operator <(pair<int, int> a, pair<int, int> b) {
    if(a.first == b.first)
        return a.second < b.second
    return a.first < b.first;
} */

void init_rmq() { // O(N * log(N))
    /// Ca sa nu avem probleme cu 0
    depth[0] = NMAX + 1;

    /// Copiem valorile in rmq
    for(int i = 0; i < euler.size(); i++) {
        rmq[0][i] = euler[i];
        inveuler[euler[i]] = i;
    }

    /// Precalculam RMQ
    for(int level = 1; level < LMAX; level++) {
        for(int i = 0; i + (1 << level) <= euler.size(); i++) {
            int a = rmq[level - 1][i];
            int b = rmq[level - 1][i + (1 << level) / 2];
            if(depth[a] > depth[b]) rmq[level][i] = b;
            else rmq[level][i] = a;
        }
    }
}


/*
int prec_lg2[(1 << LMAX)];
void precalc_lg2() {
    prec_lg2[1] = 0;
    for(int i = 2; i < (1 << LMAX); i++)
        prec_lg2[i] = prec_lg2[i / 2] + 1;
}
*/

int lg2(int length) {
    // __builtin_clz = count leading zero's
    return 31 - __builtin_clz(length);

    // return prec_lg2[length];
}

int query_rmq(int a, int b) { // O(1) - complexitate constanta
    /// a si b sunt noduri

    int posa = inveuler[a];
    int posb = inveuler[b];

    if(posa > posb) swap(posa, posb);
    if(posa == posb) return rmq[0][posa];

    // Dam query pe [posa .. posb]

    int length = posb - posa + 1;

    int lg = lg2(length);

    // [posa .............................................. posb]
    // [posa ....... posa + (1 << lg)] = candidate a
    //              candidate b = [posb - (1 << lg) .. .... posb]

    int cand_a = rmq[lg][posa];
    int cand_b = rmq[lg][posb - (1 << lg) + 1];

    if(depth[cand_a] > depth[cand_b]) return cand_b;
    else return cand_a;
}

// #ifndef LOCAL
ifstream in("lca.in");
ofstream out("lca.out");

#define cin in
#define cout out
// #endif // LOCAL

int main() {
    assert((1 << LMAX) > 2 * NMAX);

    int n, q; cin >> n >> q;
    for(int i = 2; i <= n; i++) {
        int y; cin >> y;
        g[y].push_back(i);
    }

    liniarize(1, -1, 1);
    init_rmq();

    for(int i = 0; i < q; i++) {
        int x, y; cin >> x >> y;
        cout << query_rmq(x, y) << '\n';
    }
}