#include <bits/stdc++.h>
#define BIT(x, bit) (bool((x) & (1 << (bit))))
template<typename It>
void print_iter(It l, It r) {
for (It it = l; it != r; ++it) {
std::clog << *it << " ";
}
std::clog << "\n";
}
template<typename T>
inline void set_bit(T &x, int bit, bool to) {
if (to != bool(x & (1 << bit))) {
x ^= 1 << bit;
}
}
template<typename T, typename F>
void min_then(T &min, T x, F &&f) {
if (x < min) {
min = x;
f();
}
}
inline int log2_bit(int x) {
return 31 - __builtin_clz(x);
}
std::ifstream in("lca.in");
std::ofstream out("lca.out");
const int N = 1e5;
int n;
std::vector<int> g[N];
int en;
int e[2 * N - 1];
int ep[N];
void prepare() {
en = 2 * n - 1;
std::function<void(int, int)> dfs = [&](int u, int k) {
static int i;
ep[u] = i;
e[i++] = u;
for (int v : g[u]) {
dfs(v, k + 1);
e[i++] = u;
}
};
dfs(0, 0);
}
const int BS = 8, BN = 2 * N / BS + 1, BP = 1 << BS;
using Blk = unsigned char;
int bn, bs;
Blk blocks[BN];
struct BlockEntry {
int mi;
int l[BS], r[BS];
} bt[BP];
void process_block(Blk b, int cbs) {
auto &ent = bt[b];
if (ent.r[cbs - 1] != 0) {
return;
}
int ps = 0;
int min, mi;
min = mi = 0;
for (int i = 1; i < cbs; ++i) {
ps += BIT(b, i - 1) ? 1 : -1;
min_then(min, ps, [&] {
mi = i;
});
ent.l[i] = mi;
}
ent.mi = mi;
ps = min = 0;
mi = cbs - 1;
ent.r[mi] = mi;
for (int i = cbs - 2; i >= 0; --i) {
ps -= BIT(b, i) ? 1 : -1;
min_then(min, ps, [&] {
mi = i;
});
ent.r[i] = mi;
}
}
void block() {
bs = std::log2(en) / 2;
bn = std::ceil(en / bs);
for (int i = 0, bi = 0; i < en; i += bs, ++bi) {
int cbs = std::min(bs, en - i);
Blk b = (1 << bs) - 1;
for (int j = 0; j < cbs - 1; ++j) {
set_bit(b, j, e[i + j + 1] - e[i + j] > 0);
}
blocks[bi] = b;
process_block(b, cbs);
}
}
const int LOG_BN = 15;
int st[LOG_BN][BN];
inline int get_abs_pos_val(int bi, int i) {
return e[bi * bs + i];
}
inline int get_block_min(int bi) {
return get_abs_pos_val(bi, bt[blocks[bi]].mi);
}
void prepare_rmq() {
for (int i = 0; i < bn; ++i) {
st[0][i] = i;
}
auto min = [&](int bi1, int bi2) {
int u1, u2;
u1 = get_block_min(bi1);
u2 = get_block_min(bi2);
return u1 < u2 ? bi1 : bi2;
};
for (int exp = 1; (1 << exp) < bn; ++exp) {
int p = 1 << exp;
for (int i = 0; i + p < bn; ++i) {
st[exp][i] = min(st[exp - 1][i], st[exp - 1][i + p / 2]);
}
}
}
int rmq(int l, int r) {
int k = std::max(0, log2_bit(r - l + 1));
int bi1, bi2;
bi1 = st[k][l];
bi2 = st[k][r - (1 << k) + 1];
int u1, u2;
u1 = get_block_min(bi1);
u2 = get_block_min(bi2);
return std::min(u1, u2);
}
int get_min_in_local_block(int i, bool left) {
Blk b = blocks[i / bs];
auto &v = left ? bt[b].l : bt[b].r;
return v[i % bs];
}
int lca(int u, int v) {
int up = ep[u];
int vp = ep[v];
if (up > vp) {
std::swap(u, v);
std::swap(up, vp);
}
int ubi = up / bs;
int vbi = vp / bs;
if (ubi == vbi) {
return *std::min_element(e + up, e + vp + 1);
}
int min_right_u = get_abs_pos_val(ubi, get_min_in_local_block(up, false));
int min_left_v = get_abs_pos_val(vbi, get_min_in_local_block(vp, true));
if (vbi - ubi == 1) {
return std::min(min_right_u, min_left_v);
}
return std::min(
{min_right_u, min_left_v, rmq(ubi + 1, vbi - 1)});
}
int main() {
int q;
in >> n >> q;
for (int i = 1; i < n; ++i) {
int u;
in >> u;
--u;
g[u].push_back(i);
}
prepare();
block();
prepare_rmq();
for (int i = 0; i < q; ++i) {
int u, v;
in >> u >> v;
--u, --v;
out << lca(u, v) + 1 << "\n";
}
}