Problem: Polycarpus got hold of a family tree. The found tree describes the family relations of n people, numbered from 1 to n. Every person in this tree has at most one direct ancestor. Also, each person in the tree has a name, the names are not necessarily unique.

We call the man with a number a a 1-ancestor of the man with a number b, if the man with a number a is a direct ancestor of the man with a number b.

We call the man with a number a a k-ancestor (k > 1) of the man with a number b, if the man with a number b has a 1-ancestor, and the man with a number a is a (k - 1)-ancestor of the 1-ancestor of the man with a number b.

In the tree the family ties do not form cycles. In other words there isn't a person who is his own direct or indirect ancestor (that is, who is an x-ancestor of himself, for some x, x > 0).

We call a man with a number a the k-son of the man with a number b, if the man with a number b is a k-ancestor of the man with a number a.

Polycarpus is very much interested in how many sons and which sons each person has. He took a piece of paper and wrote m pairs of numbers vi, ki. Help him to learn for each pair vi, ki the number of distinct names among all names of the ki-sons of the man with number vi.

Input

The first line of the input contains a single integer n (1 ≤ n ≤ 105) — the number of people in the tree. Next n lines contain the description of people in the tree. The i-th line contains space-separated string si and integer ri (0 ≤ ri ≤ n), where si is the name of the man with a number i, and ri is either the number of the direct ancestor of the man with a number i or 0, if the man with a number i has no direct ancestor. 

The next line contains a single integer m (1 ≤ m ≤ 105) — the number of Polycarpus's records. Next m lines contain space-separated pairs of integers. The i-th line contains integers vi, ki (1 ≤ vi, ki ≤ n).

It is guaranteed that the family relationships do not form cycles. The names of all people are non-empty strings, consisting of no more than 20 lowercase English letters.

Output

Print m whitespace-separated integers — the answers to Polycarpus's records. Print the answers to the records in the order, in which the records occur in the input.

Examples

Input

6
pasha 0
gerald 1
gerald 1
valera 2
igor 3
olesya 1
5
1 1
1 2
1 3
3 1
6 1


Output

2
2
0
1
0


Input

6
valera 0
valera 1
valera 1
gerald 0
valera 4
kolya 4
7
1 1
1 2
2 1
2 2
4 1
5 1
6 1


Output

1
0
0
0
2
0
0

Solution (in JAVA):

Solution:
import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;


public class Test {
	public static void redirectIn(String fileName){
		FileInputStream fileStream=null;
		try {
			fileStream=new FileInputStream(fileName);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		BufferedInputStream input=new BufferedInputStream(fileStream);
		System.setIn(input);
	}
	public static void redirectOut(String fileName){
		FileOutputStream fileStream=null;
		try {
			fileStream=new FileOutputStream(fileName);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		}
		PrintStream output=new PrintStream(fileStream);
		System.setOut(output);
	}
	public static Scanner initCin(){
//		redirectIn("test.in");
		return new Scanner(new BufferedInputStream(System.in));
	}
	public static PrintStream initOut(){
//		redirectOut("output.txt");
		return System.out;
	}
	
	public final static PrintStream out=initOut();
	public final static Scanner cin=initCin();
	
	static int n,m;
	static List<Integer>[] nodes;
	static List<int[]>[] query;
	static List<Set<Integer>>[] dp;
	static int[] ans,ID;
	static HashMap<String, Integer> map=new HashMap<>();
	
	static List<Set<Integer>> merge(List<Set<Integer>> a,List<Set<Integer>> b){
		if(a.size()<b.size()){
			return merge(b, a);
		}
		for(int i=a.size()-1,j=b.size()-1;i>=0&&j>=0;--i,--j){
			Set<Integer> aSet = a.get(i);
			Set<Integer> bSet = b.get(j);
			aSet.addAll(bSet);
		}
		return a;
	}
	static void dfs(int u,int depth){
		for(int i:nodes[u]){
			dfs(i, depth+1);
			dp[u]=merge(dp[u], dp[i]);
		}
		Set<Integer> temp=new TreeSet<Integer>();
		temp.add(ID[u]);
		dp[u].add(temp);
		 for(int[] i:query[u]){
			 if(i[0]<dp[u].size()){
				 ans[i[1]]=dp[u].get(dp[u].size()-1-i[0]).size(); 
			 }
		 }
	}
	@SuppressWarnings("unchecked")
	public static void main(String[] args){
		n=cin.nextInt();
		ID=new int[n+1];
		nodes=new List[n+1];
		dp=new List[n+1];
		query=new List[n+1];
		for(int i=0;i<n+1;++i){
			nodes[i]=new ArrayList<Integer>();
			query[i]=new ArrayList<int[]>();
			dp[i]=new ArrayList<Set<Integer>>();
		}
		for(int i=1;i<=n;++i){
			String name=cin.next();
			if(!map.containsKey(name)){
				map.put(name, i);
			}
			ID[i]=map.get(name);
			nodes[cin.nextInt()].add(i);
		}
		m=cin.nextInt();
		ans=new int[m];
		for(int i=0;i<m;++i){
			int v=cin.nextInt(),k=cin.nextInt();
			query[v].add(new int[]{k,i});
		}
		dfs(0, 0);
		for(int i:ans) out.println(i);
	}
}