#include <bits/stdc++.h>

using namespace std;

#define ll long long
#define ull unsigned ll
#define vec vector
#define flist forward_list
#define um unordered_map
#define us unordered_set
#define prioq priority_queue
#define all(x) x.begin(), x.end()
#define pb push_back
#define pf push_front
#define fi first
#define se second
#define mp make_pair
#define mt make_tuple
#define ld long double
#define pll pair<ll, ll>

#define LL_MAX LLONG_MAX
#define LL_MIN LLONG_MIN
#define ULL_MAX ULLONG_MAX
#define ULL_MIN 0
#define LD_MAX LDBL_MAX
#define LD_MIN LDBL_MIN

#define nl '\n'

#define vv(type, name, n, ...) vector<vector<type>> name(n, vector<type>(__VA_ARGS__))
#define vvv(type, name, n, m, ...)                                                                                     \
    vector<vector<vector<type>>> name(n, vector<vector<type>>(m, vector<type>(__VA_ARGS__)))

// https://trap.jp/post/1224/
#define rep1(n) for(ll i=0; i<(ll)(n); ++i)
#define rep2(i,n) for(ll i=0; i<(ll)(n); ++i)
#define rep3(i,a,b) for(ll i=(ll)(a); i<(ll)(b); ++i)
#define rep4(i,a,b,c) for(ll i=(ll)(a); i<(ll)(b); i+=(c))
#define cut4(a,b,c,d,e,...) e
#define rep(...) cut4(__VA_ARGS__,rep4,rep3,rep2,rep1)(__VA_ARGS__)
#define rep1e(n) for(ll i=1; i<=(ll)(n); ++i)
#define rep2e(i,n) for(ll i=1; i<=(ll)(n); ++i)
#define rep3e(i,a,b) for(ll i=(ll)(a); i<=(ll)(b); ++i)
#define rep4e(i,a,b,c) for(ll i=(ll)(a); i<=(ll)(b); i+=(c))
#define repe(...) cut4(__VA_ARGS__,rep4e,rep3e,rep2e,rep1e)(__VA_ARGS__)
#define per1(n) for(ll i=((ll)n)-1; i>=0; --i)
#define per2(i,n) for(ll i=((ll)n)-1; i>=0; --i)
#define per3(i,a,b) for(ll i=((ll)a)-1; i>=(ll)(b); --i)
#define per4(i,a,b,c) for(ll i=((ll)a)-1; i>=(ll)(b); i-=(c))
#define per(...) cut4(__VA_ARGS__,per4,per3,per2,per1)(__VA_ARGS__)
#define per1e(n) for(ll i=((ll)n); i>=1; --i)
#define per2e(i,n) for(ll i=((ll)n); i>=1; --i)
#define per3e(i,a,b) for(ll i=((ll)a); i>=(ll)(b); --i)
#define per4e(i,a,b,c) for(ll i=((ll)a); i>=(ll)(b); i-=(c))
#define pere(...) cut4(__VA_ARGS__,per4e,per3e,per2e,per1e)(__VA_ARGS__)
#define rep_subset(i,s) for(ll i=(s); i>=0; i=(i==0?-1:(i-1)&(s)))
// #define forit(v) for (auto it = v.begin(); it != v.end(); it++)
// #define forit2(it, v) for (auto it = v.begin(); it != v.end(); it++)
// #define forrit(v) for (auto it = v.rbegin(); it != v.rend(); it++)
// #define forrit2(it, v) for (auto it = v.rbegin(); it != v.rend(); it++)

// #ifdef i_am_noob
#define bug(...) cerr << "#" << __LINE__ << ' ' << #__VA_ARGS__ << "- ", _do(__VA_ARGS__)
template<typename T> void _do(vector<vector<T>> x){cerr << "\n"; for(auto i: x) {for(auto j : i) {cerr << j << ' ';} cerr << "\n";}}
template<typename T> void _do(vector<T> x){for(auto i: x) cerr << i << ' ';cerr << "\n";}
template<typename T> void _do(set<T> x){for(auto i: x) cerr << i << ' ';cerr << "\n";}
template<typename T> void _do(unordered_set<T> x){for(auto i: x) cerr << i << ' ';cerr << "\n";}
template<typename T> void _do(T && x) {cerr << x << endl;}
template<typename T, typename ...S> void _do(T && x, S&&...y) {cerr << x << ", "; _do(y...);}
// #else
// #define bug(...) 777771449
// #endif

const ll MOD = 1e9 + 7;

const string FILENAME = "lca";
ifstream fin(FILENAME + ".in");
ofstream fout(FILENAME + ".out");

#define cin fin
#define cout fout

ll n, m, k;
vec<flist<ll>> adj;
vec<ll> tour, height, appear, log_2, blocks, blocksLowInd;
vec<vec<ll>> st, precLastBlock;
vec<vec<vec<ll>>> precBlock;

ll lca(ll a, ll b);
void dfs(ll node, ll parent, ll level);
void genStructures();
ll rmq(ll l, ll r);
ll rmqSt(ll lblock, ll rblock);

int main()
{
	cin >> n >> m;
	
	adj.resize(n);
	tour.reserve(2 * n + 1);
	height.reserve(2 * n + 1);
	appear.resize(n);
	log_2.resize(2 * n + 5);
	
	log_2[0] = -1;
	repe(log_2.size() - 1) log_2[i] = log_2[i / 2] + 1;
	
	repe(i, 2, n)
	{
		ll fath;
		cin >> fath;
		fath--;
		adj[fath].pf(i - 1);
	}
	
	dfs(0, -1, 0);
	genStructures();
	
	// bug(height);
	// bug(blocks);
	// bug(blocksLowInd);
	
	rep(m)
	{
		ll a, b;
		cin >> a >> b;
		a--;
		b--;
		
		cout << lca(a, b) + 1 << nl;
	}
	
    return 0;
}

ll lca(ll a, ll b)
{
	ll x = appear[a], y = appear[b];
	if(x > y) swap(x, y);
	
	return tour[rmq(x, y)];
}
ll rmq(ll l, ll r)
{
	// bug(l, r);
	ll lblock = l / k, rblock = r / k, minInd = l;
	if(lblock + 1 <= rblock - 1) minInd = rmqSt(lblock + 1, rblock - 1);
	
	ll lpos = l % k, rpos = r % k;
	
	// bug(lblock, rblock, lpos, rpos);
	// bug(minInd);
	
	if(lblock == rblock)
	{
		if(lblock >= blocks.size())
		{
			return lblock * k + precLastBlock[lpos][rpos];
		}
		else
		{
			return lblock * k + precBlock[blocks[lblock]][lpos][rpos];
		}
	}
	
	if(height[lblock * k + precBlock[blocks[lblock]][lpos][k - 1]] < height[minInd])
		minInd = lblock * k + precBlock[blocks[lblock]][lpos][k - 1];
	
	if(rblock >= blocks.size())
	{
		if(height[rblock * k + precLastBlock[0][rpos]] < height[minInd])
			minInd = rblock * k + precLastBlock[0][rpos];
	}
	else
	{
		if(height[rblock * k + precBlock[blocks[rblock]][0][rpos]] < height[minInd])
			minInd = rblock * k + precBlock[blocks[rblock]][0][rpos];
	}
	
	return minInd;
}
ll rmqSt(ll lblock, ll rblock)
{
	// bug(lblock, rblock);
	ll exp = log_2[rblock - lblock + 1], len = (1ll << exp);
	
	// bug(exp, st[exp][lblock], st[exp][rblock]);
	if(height[st[exp][lblock]] < height[st[exp][rblock - len + 1]]) return st[exp][lblock];
	return st[exp][rblock - len + 1];
}
void dfs(ll node, ll parent, ll level)
{
	tour.pb(node);
	height.pb(level);
	appear[node] = tour.size() - 1;
	
	for(auto nei : adj[node])
	{
		if(nei == parent) continue;
		
		dfs(nei, node, level + 1);
		
		tour.pb(node);
		height.pb(level);
	}
}
void genStructures()
{
	k = log_2[height.size()] / 2;
	blocks = vec<ll>(height.size() / k, 0);
	blocksLowInd = vec<ll>(blocks.size());
	precBlock = vec<vec<vec<ll>>>((1ll << k - 1) + 5, vec<vec<ll>>(k, vec<ll>(k, -1)));
	precLastBlock = vec<vec<ll>>(height.size() % k, vec<ll>(height.size() % k));
	
	ll bit;
	
	rep(height.size() / k * k)
	{
		if(i % k > 0)
		{
			blocks[i / k] += bit * (height[i] - height[i - 1] == -1 ? 0 : 1); // DOES IT WORK ON LARGER BLOCK SIZES?
			bit <<= 1ll;
		}
		else
		{
			blocksLowInd[i / k] = i;
			bit = 1ll;
		}
		
		if(height[i] < height[blocksLowInd[i / k]])
			blocksLowInd[i / k] = i;
	}
	
	rep(i, height.size() / k * k, height.size())
	{
		precLastBlock[i % k][i % k] = height[i];
		rep(j, i + 1, height.size())
		{
			precLastBlock[i % k][j % k] = height[precLastBlock[i % k][(j - 1) % k]] > height[j] ? j : precLastBlock[i % k][(j - 1) % k];
		}
	}
	
	st = vec<vec<ll>>(log_2[blocksLowInd.size()] + 1, vec<ll>(blocksLowInd.size()));
	rep(blocksLowInd.size())
		st[0][i] = blocksLowInd[i];
	
	rep(i, 1, st.size())
	{
		ll pw2 = (1ll << i);
		for(ll j = 0; j + pw2 - 1 < st[i].size(); j++)
		{
			st[i][j] = height[st[i - 1][j]] < height[st[i - 1][j + (pw2 >> 1ll)]] ? st[i - 1][j] : st[i - 1][j + (pw2 >> 1ll)];
		}
	}
	
	// for(auto v : st)
	// {
		// for(auto el : v) cerr << el << ' ';
		// cerr << nl;
	// }
	
	vec<ll> vals(k);
	rep(blocks.size())
	{
		ll mask = blocks[i];
		if(precBlock[mask][0][0] != -1) continue;
		
		vals[0] = 0;
		rep(j, 1, vals.size())
		{
			vals[j] = vals[j - 1] + ((mask & (1ll << j - 1)) ? 1 : -1);
		}
		
		rep(l, k)
		{
			precBlock[mask][l][l] = l;
			
			rep(r, l + 1, k)
			{
				precBlock[mask][l][r] = vals[r] < vals[precBlock[mask][l][r - 1]] ? r : precBlock[mask][l][r - 1];
			}
		}
	}
}