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 heapq
import itertools
import sys
# from typing import Counter

# import itertools
# import math
# import os
# import random

from collections import defaultdict
from functools import lru_cache
from bisect import bisect_left, bisect_right

# from heapq import heapify, heappop, heappush
# from io import BytesIO, IOBase
# from string import *

# region fastio
input = lambda: sys.stdin.readline().rstrip()
sint = lambda: int(input())
mint = lambda: map(int, input().split())
ints = lambda: list(map(int, input().split()))

# MOD = 998244353
MOD = 10 ** 9 + 7
# DIR = ((-1, 0), (0, 1), (1, 0), (0, -1))

sys.setrecursionlimit(3 * 10 ** 5)

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


def solve() -> None:
    n = sint()
    adj = [[] for _ in range(n)]
    a = [None] * n
    for i in range(n):
        s, f = input().split()
        f = int(f)
        a[i] = s
        if f:
            adj[f - 1].append(i)
    queries = [[] for _ in range(n)]
    m = sint()
    for i in range(m):
        x, k = mint()
        queries[x - 1].append((k, i))
    ans = [0] * m

    @bootstrap
    def dfs(u, fa, d):
        nonlocal ans
        dus = defaultdict(set)
        dus[d].add(a[u])
        for v in adj[u]:
            if v != fa:
                dvs = yield dfs(v, u, d + 1)
                if len(dus) < len(dvs):
                    dus, dvs = dvs, dus
                for k, st in dvs.items():
                    dus[k] |= st
                dvs.clear()
        for k, index in queries[u]:
            ans[index] = len(dus[d + k])
        yield dus
        # return dus
    dfs(0, -1, 0)

    for x in ans:
        print(x)


if __name__ == '__main__':
    solve()
