#include <bits/stdc++.h>

using namespace std;

class Graph {
private:
    struct Edge {
        int from, to;
        Edge() { }
        Edge(const int _from, const int _to) : from(_from), to(_to) { }
    };
      
    template<typename T>
    struct Range {
        struct Iterator {
            T& operator *() const { return *iter; }
            bool operator !=(const Iterator& rhs) const { return iter != rhs.iter; }
            void operator ++() { ++iter; }
            T* operator +(int i) const { return iter + i; }
            size_t operator -(const Iterator& rhs) const { return iter - rhs.iter; }
            T* iter;
        };
          
        Range(T* _first, T* _last) : first({_first}), last({_last}) { }
        T operator[] (const int i) { return *(first + i); }
        size_t size() const { return last - first; }
        Iterator& begin() { return first; }
        Iterator& end() { return last; }
        Iterator first, last;
    };
public:
    Range<int> operator [](int u) { 
        return Range<int>(&edges[offset[u]], &edges[offset[u + 1]]); 
    }
      
    Graph() = default;
    Graph(const int N, const int M=0) : n(N), offset(N + 1) {
        if (M > 0) { in.reserve(M); }
    } 
      
    void AddEdge(int x, int y) { in.emplace_back(x, y); }
      
    void Init() {
        edges.resize(in.size());
        for (auto&& e : in) { offset[e.from] += 1; }
        for (int i = 1; i <= n; i += 1) { 
            offset[i] += offset[i - 1]; 
        }
        for (auto&& e : in) { 
            edges[--offset[e.from]] = e.to; 
        }
        in.clear();
    }
      
    size_t size() const {
        return (size_t)n;
    }
private:    
    int n;
    vector<int> offset, edges;
    vector<Edge> in;
};
  
class SchieberVishkinLCA {
private:
    static inline int lsb(int value) {
        return value & -value;
    }
      
    static inline int msb(int v) {
        v |= v >> 1;
        v |= v >> 2;
        v |= v >> 4;
        v |= v >> 8;
        v |= v >> 16;
        return v >> 1;
    }
public:
    SchieberVishkinLCA() = default;
    SchieberVishkinLCA(Graph& G, int root) : idx(G.size()), max_idx(G.size()), ancestor_height(G.size()), path_parent(G.size()) {
        int n = G.size();
        vector<int> parent(n), vertices(n);
          
        auto Dfs = [&]() {
            int stack_size = 1, euler_idx = 1;
            vertices[0] = root;
            parent[root] = -1;
            while (stack_size > 0) {
                const int node = vertices[--stack_size];
                idx[node] = euler_idx++;
                for (auto&& son : G[node]) {
                    if (parent[node] != son) {
                        parent[son] = node;
                        vertices[stack_size++] = son;
                    }
                }
            }
        };
          
        auto Bfs = [&]() {
            int q_front = 0, q_end = 1;
            vertices[0] = root;
            parent[root] = -1;
            while (q_front != q_end) {
                const int node = vertices[q_front++];
                for (auto&& son : G[node]) {
                    if (parent[node] != son) {
                        parent[son] = node;
                        vertices[q_end++] = son;
                    }
                }
            }
        };
          
        Dfs(); Bfs();
        max_idx = idx;
        for (int i = n - 1; i > 0; i -= 1) {
            const int node = vertices[i];
            if (lsb(max_idx[parent[node]]) < lsb(max_idx[node])) {
                max_idx[parent[node]] = max_idx[node];
            }
        }
          
        ancestor_height[root] = 0;
        for (int i = 1; i < n; i += 1) {
            const int node = vertices[i];
            ancestor_height[node] = ancestor_height[parent[node]] | lsb(max_idx[node]);
        }
          
        path_parent[idx[root] - 1] = root;
        for (int i = 0; i < n; i += 1) {
            const int node = vertices[i];
            for (auto&& son : G[node]) {
                if (parent[node] == son) {
                    continue;
                }
                  
                path_parent[idx[son] - 1] = (max_idx[node] == max_idx[son]) ? path_parent[idx[node] - 1] : node;
            }
        }
    }
      
    int Query(int x, int y) const {
        const int Ix = max_idx[x], Iy = max_idx[y];
        const int hIx = lsb(Ix), hIy = lsb(Iy);
        const int msb_mask = msb((Ix ^ Iy) | hIx | hIy);
        const int mask = lsb(ancestor_height[x] & ancestor_height[y] & ~msb_mask);
          
        int left, right;
          
        if (mask == hIx) {
            left = x;
        } else {
            const int kMask = msb(ancestor_height[x] & (mask - 1));
            left = path_parent[((idx[x] & ~kMask) | (kMask + 1)) - 1];
        }
          
        if (mask == hIy) {
            right = y;
        } else {
            const int kMask = msb(ancestor_height[y] & (mask - 1));
            right = path_parent[((idx[y] & ~kMask) | (kMask + 1)) - 1];
        }
        return (idx[left] < idx[right]) ? left : right;
    }
private:
    vector<int> idx, max_idx, ancestor_height, path_parent;
};
  
int main() {
    #ifdef INFOARENA
    ifstream cin("lca.in");
    ofstream cout("lca.out");
    #endif

    int n, m; cin >> n >> m;
    Graph G(n, n - 1);
    for (int i = 1; i < n; i += 1) {
        int parent; cin >> parent; parent -= 1;
        G.AddEdge(parent, i);
    }
    G.Init();
      
    SchieberVishkinLCA LcaSolver(G, 0);
    for (int i = 0; i < m; i += 1) {
        int x, y; cin >> x >> y; x -= 1; y -= 1;
        cout << 1 + LcaSolver.Query(x, y) << '\n';
    }
}