#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, INT_MAX } ) {
		for (size_t i = 0; i < v.size(); i++) {
			update(i + 1, v[i]);
		}
	}

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

	int getMin(int a, int b) {
		std::pair<int, int> ret = min_helper(1, 1, n, a, b);
		return ret.second - 1;
	}

private:
	int n;
	std::vector<std::pair<int, int>> A;

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

		A[k] = std::min(A[2 * k], A[2 * k + 1]);
	}

	const std::pair<int, int>& min_helper(int k, int l, int r, int a, int b) {
		if (r < a || b < l || r < l)
			return { INT_MAX, INT_MAX };

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

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

		return std::min(min_l, 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->getMin(a + 1, b + 1);

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