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
readline = sys.stdin.readline
write = sys.stdout.write

def dsu_on_tree(N, G, s0, PropDS):
    order = []
    prt = [-1]*N
    depth = [-1]*N

    que = [s0]
    pn = [-1]*N
    used = [0]*N
    used[s0] = 1
    depth[s0] = 0
    while que:
        v = que.pop()
        d = depth[v] + 1
        for w in G[v]:
            if used[w]:
                continue
            used[w] = 1
            que.append(w)
            prt[w] = v
            depth[w] = d
        pn[v] = len(order)
        order.append(v)

    sz = [0]*N
    tmp_ps = [[i] for i in range(N)]
    h_ps = []
    for v in reversed(order):
        p = prt[v]
        m_sz = 0
        h = -1
        s = 1
        for w in G[v]:
            if p == w:
                continue
            if m_sz < sz[w]:
                m_sz = sz[w]
                h = w
            s += sz[w]
        if h != -1:
            tmp_ps[v] = tmp_ps[h]
            tmp_ps[v].append(v)
            for w in G[v]:
                if w == p or w == h:
                    continue
                h_ps.append(tmp_ps[w])
        sz[v] = s
    h_ps.append(tmp_ps[s0])

    ph = PropDS(depth)
    for path in h_ps:
        h = -1
        for v in path:
            p = prt[v]

            for w in G[v]:
                if w == p or w == h:
                    continue
                for c in order[pn[w]:pn[w] + sz[w]]:
                    ph.add(c)
            ph.add(v)
            ph.query(v)
            h = v
        ph.reset()

def solve():
    N = int(readline())
    G = [[] for i in range(N+1)]
    prt = [-1]*N
    names = [None]*N
    lbs = [-1]*(N+1)
    ns = set()
    for i in range(N):
        name, r = readline().split(); r = int(r)
        if r == 0:
            s = i
            prt[i] = N
            G[N].append(i)
        else:
            prt[i] = r-1
            G[r-1].append(i)
        names[i] = name
        ns.add(name)
    mp = {name: i for i, name in enumerate(ns)}
    lbs[:N] = map(mp.__getitem__, names)

    M = int(readline())
    qs = [[] for i in range(N+1)]
    for i in range(M):
        v, k = map(int, readline().split())
        qs[v-1].append((k, i))

    ans = [-1]*M

    class PropDS:
        def __init__(self, depth):
            self.sets = [set() for i in range(N+1)]
            self.depth = depth

            self.us = set()

        def add(self, v):
            d = self.depth[v]
            self.sets[d].add(lbs[v])

            self.us.add(d)


        def reset(self):
            for u in self.us:
                self.sets[u].clear()

            self.us.clear()

        def query(self, v):
            d = self.depth[v]
            for k, i in qs[v]:
                ans[i] = len(self.sets[d + k])

    dsu_on_tree(N+1, G, N, PropDS)
    for i in range(M):
        write("%d\n" % ans[i])

solve()
