import java.util.*;
import java.io.*;
// n k
// p_2 c_2
// ...
// p_n c_n
// x_1 y_1
// x_2 y_2
// ...
// x_k y_k

public class Main {
    static List<List<Integer>> graph; 
    static int n;
    static int[][] parent; 
    static int max_log  = 18;
    public static void setParent() {
        for (int k=1; i<max_log; k++) {
            for (int i=1; i<=n; i++) {
                parent[k][i] = parent[k-1][parent[k-1][i]] 
            }
        }
    }
    // lca
    public static int getLCA(int u, int v, int[] depth) {
        if (depth[u] < depth[v]) {
            int temp = u; u=v; v=temp; 
        }

        for (int k=max_log-1; k>=0; k--) {
            if (depth[u] - depth[v] >= (1 << k)) {
                u = parent[k][u];
            }
        }

        if (u==v) return u; 

        for (int k=max_log-1; k>=0; k--) {
            if (parent[k][u] != parent[k][v]) {
                u = parent[k][u]; 
                v = parent[k][v];
            }
        }
        return parent[0][u]; 
        
    }
    
    
    public static int[] bfs(ArrayList<Integer> a) {
        int[] visited = new int[n+1];
        Arrays.fill(visited, -1);
        Queue<Integer> q = new ArrayDeque<>();
        for (int num : a) {
            q.add(num);
            visited[num] = 0;
        }
        
        while(!q.isEmpty()) {
            int now = q.poll();
            for (int next : graph.get(now)) {
                if (visited[next] == -1) {
                    visited[next] = visited[now] + 1;
                    q.add(next);
                }
            }
        }
        return visited;
    }
    public static void main(String[] args) throws IOException {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        
        n = Integer.parseInt(st.nextToken());
        int k = Integer.parseInt(st.nextToken());
        
        graph = new ArrayList<>();
        for (int i=0; i<n+1; i++) {
            graph.add(new ArrayList<>());
        }
        
        ArrayList<Integer> warp_node = new ArrayList<>();
        
        for (int i=2; i<n+1; i++) {
            st = new StringTokenizer(br.readLine());
        
            int p = Integer.parseInt(st.nextToken());
            int c = Integer.parseInt(st.nextToken());
            
            graph.get(i).add(p);
            graph.get(p).add(i);
            
            if (c==1) {
                warp_node.add(i);
            }
        }
        
       
        
        ArrayList<Integer> one = new ArrayList<>();
        one.add(1);
        
        int[] visited_from_one = bfs(one);
        int[] visited_from_warp = bfs(warp_node);
        
        for (int i=0; i<k; i++) 
        {
            st = new StringTokenizer(br.readLine());
            int x = Integer.parseInt(st.nextToken());
            int y = Integer.parseInt(st.nextToken());
            
            int dist1 = Math.abs(visited_from_one[y]-visited_from_one[x]);
            int dist2 = Math.abs(visited_from_one[x] + visited_from_warp[y]);
            int dist3 = Math.abs(visited_from_one[y] + visited_from_warp[x]);
            
            int xx = Math.min(dist1, dist2);
            int ans = Math.min(xx, dist3);
            
            System.out.println(ans);
            
        }
        
        
        
        
        
        
        
        
    }
}