Evlampiy was gifted a rooted tree. The vertices of the tree are numbered from 1 to n. Each of its vertices also has an integer a_i written on it. For each vertex i, Evlampiy calculated c_i — the number of vertices j in the subtree of vertex i, such that a_j < a_i. 

<image>Illustration for the second example, the first integer is a_i and the integer in parentheses is c_i

After the new year, Evlampiy could not remember what his gift was! He remembers the tree and the values of c_i, but he completely forgot which integers a_i were written on the vertices.

Help him to restore initial integers!

Input

The first line contains an integer n (1 ≤ n ≤ 2000) — the number of vertices in the tree.

The next n lines contain descriptions of vertices: the i-th line contains two integers p_i and c_i (0 ≤ p_i ≤ n; 0 ≤ c_i ≤ n-1), where p_i is the parent of vertex i or 0 if vertex i is root, and c_i is the number of vertices j in the subtree of vertex i, such that a_j < a_i.

It is guaranteed that the values of p_i describe a rooted tree with n vertices.

Output

If a solution exists, in the first line print "YES", and in the second line output n integers a_i (1 ≤ a_i ≤ {10}^{9}). If there are several solutions, output any of them. One can prove that if there is a solution, then there is also a solution in which all a_i are between 1 and 10^9.

If there are no solutions, print "NO".

Examples

Input


3
2 0
0 2
2 0


Output


YES
1 2 1 

Input


5
0 1
1 3
2 1
3 0
2 0


Output


YES
2 3 2 1 2
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**5)
input = sys.stdin.readline

# Input
n = int(input())
if n == 1:
    p, c = [int(item) for item in input().split()]
    if c == 0:
        print("YES")
        print(1)
    else:
        print("NO")
    exit()
edge = [[] for _ in range(n)]
par = None
cs = [0] * n
for i in range(n):
    p, c = [int(item) for item in input().split()]
    if p == 0:
        par = i
    else:
        edge[p-1].append(i)
        edge[i].append(p-1)
    cs[i] = c

cnt = 0
def dfs(p, v):
    global cnt
    if p != -1 and len(edge[v]) == 1:
        if cs[v] != 0:
            print("NO")
            exit()
        cnt += 1
        return [(cnt, v)]
    base = 0
    narr = []
    for nv in edge[v]:
        if p == nv:
            continue
        arr = dfs(v, nv)
        nbase = 0
        for val, index in arr:
            nbase = max(nbase, val)
            narr.append((val + base, index))
        base += nbase
    narr.sort()
    if cs[v] > len(narr):
        print("NO")
        exit()
    elif cs[v] == len(narr):
        narr.append((narr[-1][0] + 1, v))
        return narr
    if cs[v] == 0:
        tmp = []
        for val, index in narr:
            tmp.append((val + 1, index))
        narr = tmp[:]
        narr.append((narr[0][0] - 1, v))
        return narr
    if narr[cs[v]][0] - narr[cs[v]-1][0] == 1:
        tmp = []
        for val, index in narr:
            tmp.append((val * 2, index))
        narr = tmp[:]
        narr.append((narr[cs[v]-1][0] + 1, v))
    else:
        narr.append((narr[cs[v]-1][0] + 1, v))
    return narr

# Proc
ret = dfs(-1, par)

# Compress
seen = set()
for val, _ in ret:
    seen.add(val)
seen = list(seen)
seen.sort()
comp = dict()
for i, item in enumerate(seen):
    comp[item] = i + 1

# Answer
ans = [0] * n
for val, index in ret:
    ans[index] = val
print("YES")
print(" ".join([str(comp[item]) for item in ans]))