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
import sys

# BIT aka Fenwick tree
# sum
class BIT():
    def __init__(self, n):
        self.n = n
        self.tree = [0] * n
    
    def _F(self, i):
        return i & (i + 1)
    
    def _getSum(self, r):
        '''
        sum on interval [0, r]
        '''
        result = 0
        while r >= 0:
            result += self.tree[r]
            r = self._F(r) - 1
        return result
    
    def getSum(self, l, r):
        '''
        sum on interval [l, r]
        '''
        return self._getSum(r) - self._getSum(l - 1)
    
    def _H(self, i):
        return i | (i + 1)
    
    def add(self, i, value=1):
        while i < self.n:
            self.tree[i] += value
            i = self._H(i)

# inf = open('input.txt', 'r')
# reader = (line.rstrip() for line in inf)
reader = (line.rstrip() for line in sys.stdin)
input = reader.__next__

n = int(input())
# n = 5 * 10 ** 5
cs = [0] * n
ps = [0] * n
children = [[] for _ in range(n)]
for i in range(n):
    p, c = map(int, input().split())
    # p, c = i, 0
    if p > 0:
        ps[i] = p - 1
        children[p - 1].append(i)
    else:
        root = i
    cs[i] = c

# inf.close()

visited = [False] * n
stack = [root]
prev = -1
rank = [1] * n
while stack:
    v = stack.pop()
    if not visited[v]:
        visited[v] = True
        for to in children[v]:
            stack.append(v)
            stack.append(to)
    else:
        rank[v] += rank[prev]
    prev = v
# print(rank)

used = BIT(n)

ans = [None] * n
stack = [root]
while stack:
    v = stack.pop()
    kth = cs[v] + 1
    if kth > rank[v]:
        print('NO')
        sys.exit()
    L = -1
    R = n-1
    while L + 1 < R:
        m = (L + R) >> 1
        if m + 1 - used.getSum(0, m) < kth:
            L = m
        else:
            R = m
    ans[v] = R + 1
    used.add(R)
    stack.extend(children[v])

print('YES')
print(*ans)
