#define MAX_N 100000

#include <fstream>
#include <vector>
#include <algorithm>
#include <utility>
using namespace std;

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

int n, m, e, P[MAX_N + 1], N[MAX_N + 1], E[MAX_N * 2], IGM[18][MAX_N * 2];
vector<int> G[MAX_N + 1];

int MinimGama(int x, int y);
void GamaMinima();
void Df(int nod, int niv);
int Log2(int x);

int main()
{
	fin >> n >> m;
	for (int i = 1, x; i < n; ++i)
	{
		fin >> x;
		G[x].push_back(i + 1);
	}
	
	GamaMinima();
	
	for (int i = 0, x, y; i < m; ++i)
	{
		fin >> x >> y;
		fout << MinimGama(x, y) << '\n';
	}
	
	fin.close();
	fout.close();
	return 0;
}

int MinimGama(int x, int y)
{
	x = P[x];
	y = P[y];
	if (x > y) { swap(x, y); }
	
	int p = Log2(y - x + 1);
	int nodMin1 = E[IGM[p][x]], nodMin2 = E[IGM[p][y - (1 << p) + 1]];
	return (N[nodMin1] < N[nodMin2]) ? nodMin1 : nodMin2;
}

void GamaMinima()
{
	Df(1, 1);
	
	for (int i = 1; i <= e; ++i)
	{
		IGM[0][i] = i;
	}
	
	for (int p = 1; (1 << p) < e; ++p)
	{
		for (int i = 1; i + (1 << (p - 1)) <= e; ++i)
		{
			int nodMin1 = E[IGM[p - 1][i]], nodMin2 = E[IGM[p - 1][i + (1 << (p - 1))]];
			
			IGM[p][i] = (N[nodMin1] < N[nodMin2]) ? IGM[p - 1][i] : IGM[p - 1][i + (1 << (p - 1))];
		}
	}
}

void Df(int nod, int niv)
{
	N[nod] = niv;
	
	E[P[nod] = ++e] = nod;
	for (int vecin : G[nod])
	{	
		Df(vecin, niv + 1);
		E[++e] = nod;
	}
}

int Log2(int x)
{
	for (int i = sizeof(x) * 8 - 1; i >= 0; --i)
	{
		if (x & (1 << i))
		{
			return i;
		}	
	}
	
	return 0;
}