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* &gt; 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* &gt; 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 *v*<sub class="lower-index">*i*</sub>, *k*<sub class="lower-index">*i*</sub>. Help him to learn for each pair *v*<sub class="lower-index">*i*</sub>, *k*<sub class="lower-index">*i*</sub> the number of distinct names among all names of the *k*<sub class="lower-index">*i*</sub>-sons of the man with number *v*<sub class="lower-index">*i*</sub>.
The first line of the input contains a single integer *n* (1 ≤ *n* ≤ 10<sup class="upper-index">5</sup>) — 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 *s*<sub class="lower-index">*i*</sub> and integer *r*<sub class="lower-index">*i*</sub> (0 ≤ *r*<sub class="lower-index">*i*</sub> ≤ *n*), where *s*<sub class="lower-index">*i*</sub> is the name of the man with a number *i*, and *r*<sub class="lower-index">*i*</sub> 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* ≤ 10<sup class="upper-index">5</sup>) — the number of Polycarpus's records. Next *m* lines contain space-separated pairs of integers. The *i*-th line contains integers *v*<sub class="lower-index">*i*</sub>, *k*<sub class="lower-index">*i*</sub> (1 ≤ *v*<sub class="lower-index">*i*</sub>, *k*<sub class="lower-index">*i*</sub> ≤ *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.
import sys
import random

input = sys.stdin.readline
rd = random.randint(10 ** 9, 2 * 10 ** 9)

n = int(input())
p = []
name = []
for _ in range(n):
    s = input().strip().split()
    name.append(s[0])
    p.append(int(s[1]))
g = [[] for _ in range(n)]
for i in range(n):
    if p[i] == 0:
        continue
    g[p[i] - 1].append(i)
q = int(input())
queries = [[] for _ in range(n)]
ans = [0] * q
for i in range(q):
    x, d = map(int, input().split())
    queries[x - 1].append((d, i))
from collections import defaultdict

from types import GeneratorType
def bootstrap(f, stack=[]):
    def wrappedfunc(*args, **kwargs):
        if stack:
            return f(*args, **kwargs)
        else:
            to = f(*args, **kwargs)
            while True:
                if type(to) is GeneratorType:
                    stack.append(to)
                    to = next(to)
                else:
                    stack.pop()
                    if not stack:
                        break
                    to = stack[-1].send(to)
            return to
    return wrappedfunc

@bootstrap
def dfs(son, depth):
    ds,l = defaultdict(set),1
    ds[depth].add(name[son])
    for x in g[son]:
        dx,ls = yield dfs(x, depth + 1)
        if ls > l:
            ds, dx = dx, ds
        l += ls
        for k, v in dx.items():
            ds[k] |= v
        dx.clear()

    for d, i in queries[son]:
        ans[i] = len(ds[d + depth])
    yield ds,l


for i in range(n):
    if p[i] == 0:
        dfs(i, 0)
for i in ans:
    print(i)
