#include <iostream>
#include <fstream>
#include <vector>
#include <list>
#include <algorithm>
#include <memory>

#include <climits>

namespace IA {
	// Inforarena helper. Source http://en.cppreference.com/w/cpp/memory/unique_ptr/make_unique
	template<typename T, typename... Args>
	std::unique_ptr<T> make_unique(Args&&... args) {
		return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
	}
}

class RMQ {
public:
	RMQ(const std::vector<int>& _v) : v(_v), log(v.size()), mins(20, std::vector<int>(v.size())) {
		build();
	}

	int min(int a, int b) {
		if (a > b)
			std::swap(a, b);
		int delta = b - a + 1;
		if (v[mins[log[delta]][a]] < v[mins[log[delta]][b - (1 << log[delta]) + 1]])
			return mins[log[delta]][a];
		else
			return mins[log[delta]][b - (1 << log[delta]) + 1];
	}

private:
	const std::vector<int>& v;
	std::vector<int> log;
	std::vector<std::vector<int>> mins;
	void build() {
		int n = v.size();
		for (int i = 2; i < n; i++)
			log[i] = log[i / 2] + 1;
		for (int i = 0; i < n; i++)
			mins[0][i] = i;
		for (int j = 1; (1 << j) <= n; j++)
			for (int i = 0; i + (1 << j) - 1 < n; i++)
				if (v[mins[j - 1][i]] < v[mins[j - 1][i + (1 << (j - 1))]])
					mins[j][i] = mins[j - 1][i];
				else
					mins[j][i] = mins[j - 1][i + (1 << (j - 1))];
	}
};
class Graph {
public:
	Graph(int n) : links(n), e_node(2 * n - 1), e_depth(2 * n - 1), e_idx(n), rmq(nullptr) { }
	
	void add_link(int u, int v) {
		links[u].push_back(v);
	}

	void lca_precompute() {
		int k = 0;
		lca_helper(k, 0, 0);

		rmq = IA::make_unique<RMQ>(e_depth);
	}

	int lca(int u, int v) {
		int a = std::min(e_idx[u], e_idx[v]);
		int b = std::max(e_idx[u], e_idx[v]);

		int min = rmq->min(a, b);

		return e_node[min];
	}

private:
	std::vector<std::list<int>> links;
	std::vector<int> e_node;
	std::vector<int> e_depth;
	std::vector<int> e_idx; // index of node in array
	std::unique_ptr<RMQ> rmq;

	void lca_helper(int& k, int d, int v) {
		e_node[k] = v;
		e_depth[k] = d;
		e_idx[v] = k;
		k++;

		for (int u : links[v]) {
			lca_helper(k, d + 1, u);

			e_node[k] = v;
			e_depth[k] = d;
			k++;
		}
	}
};

int main() {
	std::ifstream in("lca.in");
	std::ofstream out("lca.out");

	int n, m;
	in >> n >> m;

	Graph g(n);
	for (int i = 2; i <= n; i++) {
		int x;
		in >> x;
		g.add_link(x - 1, i - 1);
	}

	g.lca_precompute();

	for (int i = 0; i < m; i++) {
		int u, v;
		in >> u >> v;
		int r = g.lca(u - 1, v - 1);
		out << r + 1 << "\n";
	}

	return 0;
}