#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 SegmentTree {
public:
	SegmentTree(const std::vector<int>& _v) : n(_v.size()), A(4 * _v.size(), INT_MAX ), v(_v) {
		for (size_t i = 0; i < v.size(); i++) {
			update(i + 1);
		}
	}

	void update(int i) {
		update_helper(1, 1, n, i);
	}

	int getMinIdx(int a, int b) {
		return min_helper(1, 1, n, a + 1, b + 1);
	}

private:
	int n;
	std::vector<int> A;
	const std::vector<int>& v;

	void update_helper(int k, int l, int r, int pos) {
		if (l == r) {
			A[k] = l - 1;
			return;
		}
		int m = (l + r) / 2;
		if (pos <= m)
			update_helper(2 * k, l, m, pos);
		else
			update_helper(2 * k + 1, m + 1, r, pos);

		if (A[2 * k] == INT_MAX) {
			A[k] = A[2 * k + 1];
			return;
		}

		if (A[2 * k + 1] == INT_MAX) {
			A[k] = A[2 * k];
			return;
		}

		if (v[A[2 * k]] < v[A[2 * k + 1]])
			A[k] = A[2 * k];
		else 
			A[k] = A[2 * k + 1];
	}

	int min_helper(int k, int l, int r, int a, int b) {
		if (r < a || b < l || r < l)
			return INT_MAX;

		if (a <= l && r <= b)
			return A[k];

		int m = (l + r) / 2;
		int min_l = min_helper(k * 2, l, m, a, b);
		int min_r = min_helper(k * 2 + 1, m + 1, r, a, b);

		if (min_l == INT_MAX)
			return min_r;
		if (min_r == INT_MAX)
			return min_l;

		if (v[min_l] < v[min_r])
			return min_l;
		else
			return min_r;
	}
};

class Graph {
public:
	Graph(int n) : links(n), e_node(2 * n - 1), e_depth(2 * n - 1), e_idx(n), st(nullptr) { }
	
	void add_link(int u, int v) {
		links[u].push_back(v);
	}

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

		st = IA::make_unique<SegmentTree>(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 = st->getMinIdx(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<SegmentTree> st;

	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;
}