#include <fstream>
#include <iostream>
#include <vector>

#define MAXN 100001
#define MAXRMQ 20

#define min(a, b) (a) < (b) ? a : b
#define max(a, b) (a) > (b) ? a : b

using namespace std;

vector<int> tree[MAXN];
int first_appearance_index[MAXN];
vector<int> euler_level;
vector<int> euler_node;
int rmq[MAXRMQ][MAXN << 2];
int log[MAXN];

void calculate_euler(int node, int level) {
	static int index = 0;

	first_appearance_index[node] = index++;
	euler_level.push_back(level);
	euler_node.push_back(node);

	for(unsigned int i = 0; i < tree[node].size(); i++) {
		calculate_euler(tree[node][i], level + 1);
		index++;
		euler_level.push_back(level);
		euler_node.push_back(node);
	}
}

void precalculate_rmq() {
	for(unsigned int i = 2; i < euler_level.size(); i++)
		log[i] = log[i >> 1] + 1;

	for(unsigned int j = 0; j < euler_level.size(); j++)
		rmq[0][j] = j;
	
	int offset;
	for(unsigned int i = 1; (1 << i) <= euler_level.size(); i++)
		for(unsigned int j = 0; j <= euler_level.size() - (1 << i); j++) {
			offset = 1 << (i - 1);
			rmq[i][j] = rmq[i - 1][j + offset];
			if (euler_level[rmq[i - 1][j]] < euler_level[rmq[i][j]])
				rmq[i][j] = rmq[i - 1][j];
		}
}

int get_rmq_min(int index1, int index2) {
	int distance = index2 - index1 + 1;
	int lg = log[distance];
	int offset = distance - (1 << lg);

	return euler_level[rmq[lg][index1]] < euler_level[rmq[lg][index1 + offset]] ? rmq[lg][index1] : rmq[lg][index1 + offset];
	
}

int main(void) {
	ifstream f("lca.in");
	ofstream g("lca.out");
	
	int nodes, queries;
	f >> nodes >> queries;
	
	int father;
	for (int i = 1; i < nodes; i++) {
		f >> father;
		tree[father].push_back(i + 1);
	}

	calculate_euler(1, 0);
	precalculate_rmq();
	return 0;

	int node1, node2;
	int index1, index2;
	while(queries--) {
		f >> node1 >> node2;
		index1 = min(first_appearance_index[node1], first_appearance_index[node2]);
		index2 = max(first_appearance_index[node1], first_appearance_index[node2]);
		g << euler_node[get_rmq_min(index1, index2)] << '\n';
	}

	return 0;
}