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
import java.io.*;
import java.util.*;
public class Main
{
	int n,time,level[],start[],end[];
	ArrayList<Integer> list[],vlist[];
	boolean visited[];
	private void solve()throws Exception
	{
		n=nextInt();
		list=new ArrayList[n+1];
		for(int i=1;i<=n;i++)
			list[i]=new ArrayList<>();
		for(int i=1;i<=n;i++)
		{
			int p=nextInt();
			if(p!=0)
			{
				list[i].add(p);
				list[p].add(i);
			}
		}
		time=0;
		visited=new boolean[n+1];
		level=new int[n+1];
		vlist=new ArrayList[n+1];
		start=new int[n+1];
		end=new int[n+1];
		for(int i=1;i<=n;i++)
			vlist[i]=new ArrayList<>();
		for(int i=1;i<=n;i++)
			if(!visited[i])
				dfs(i,0);
		Lca lca=new Lca(n,list);
		int m=nextInt();
		while(m-->0)
		{
			int v=nextInt();
			int p=nextInt();
			int l=lca.ancestor(v,p);
			if(l==0)
			{
				out.println(0);
				continue;
			}
			out.println(floor(end[l],vlist[level[v]])-floor(start[l]-1,vlist[level[v]])-1);
		}
	}
	void dfs(int v,int p)
	{
		visited[v]=true;
		level[v]=level[p]+1;
		start[v]=++time;
		vlist[level[v]].add(start[v]);
		for(int vv:list[v])
			if(vv!=p)
				dfs(vv,v);
		end[v]=time;
	}
	int floor(int x,ArrayList<Integer> a)
	{
		int low=0,high=a.size()-1,ans=0;
		while(low<=high)
		{
			int mid=(low+high)/2;
			if(a.get(mid)<=x)
			{
				ans=mid+1;
				low=mid+1;
			}
			else
				high=mid-1;
		}
		return ans;
	}
	class Lca
	{
		final int logn=20;
		int n,ancestor[][],depth[];
		ArrayList<Integer> list[];
		boolean visited[];
		Lca(int n,ArrayList<Integer> list[])
		{
			this.n=n;
			this.list=list;
			ancestor=new int[n+1][logn+1];
			depth=new int[n+1];
			depth[0]=-1;
			visited=new boolean[n+1];
			for(int i=1;i<=n;i++)
				if(!visited[i])
					dfs(i,0);
			for(int j=1;j<=logn;j++)
				for(int i=1;i<=n;i++)
					ancestor[i][j]=ancestor[ancestor[i][j-1]][j-1];
		}
		void dfs(int v,int p)
		{
			visited[v]=true;
			depth[v]=depth[p]+1;
			ancestor[v][0]=p;
			for(int vv:list[v])
				if(vv!=p)
					dfs(vv,v);
		}
		//ancestor(i,j) is the jth ancestor of i
		int ancestor(int i,int j)
		{
			for(int k=20;k>=0;k--)
				if(((j>>k)&1)==1)
					i=ancestor[i][k];
			return i;
		}
		//lca(i,j) is the lca i and j
		int lca(int i,int j)
		{
			if(depth[i]>depth[j])
			{
				int temp=i;
				i=j;
				j=temp;
			}
			int d=depth[j]-depth[i];
			for(int k=20;k>=0;k--)
				if(((d>>k)&1)==1)
					j=ancestor[j][k];
			if(i==j)
				return i;
			for(int k=20;k>=0;k--)
				if(ancestor[i][k]!=ancestor[j][k])
				{
					i=ancestor[i][k];
					j=ancestor[j][k];
				}
			return ancestor[i][0];
		}
		//dist(i,j) is the distance between i and j
		int dist(int i,int j)
		{
			if(depth[i]>depth[j])
			{
				int temp=i;
				i=j;
				j=temp;
			}
			int d=depth[j]-depth[i];
			int ret=d;
			for(int k=20;k>=0;k--)
				if(((d>>k)&1)==1)
					j=ancestor[j][k];
			if(i==j)
				return ret;
			for(int k=20;k>=0;k--)
				if(ancestor[i][k]!=ancestor[j][k])
				{
					i=ancestor[i][k];
					j=ancestor[j][k];
					ret+=2*(1<<k);
				}
			ret+=2;
			return ret;
		}
	}

	 
	///////////////////////////////////////////////////////////

	public void run()throws Exception
	{
		br=new BufferedReader(new InputStreamReader(System.in));
		st=null;
		out=new PrintWriter(System.out);

		solve();
		
		br.close();
		out.close();
	}
	public static void main(String args[])throws Exception{
		new Main().run();
	}
	BufferedReader br;
	StringTokenizer st;
	PrintWriter out;
	String nextToken()throws Exception{
		while(st==null || !st.hasMoreTokens())
		st=new StringTokenizer(br.readLine());
		return st.nextToken();
	}
	String nextLine()throws Exception{
		return br.readLine();
	}
	int nextInt()throws Exception{
		return Integer.parseInt(nextToken());
	}
	long nextLong()throws Exception{
		return Long.parseLong(nextToken());
	}
	double nextDouble()throws Exception{
		return Double.parseDouble(nextToken());
	}
}