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 java.util.*;
import java.lang.*;
import java.io.*;

public class Main
{
	PrintWriter out = new PrintWriter(System.out);
	BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer tok = new StringTokenizer("");
    String next() throws IOException {
        if (!tok.hasMoreTokens()) { tok = new StringTokenizer(in.readLine()); }
        return tok.nextToken();
    }
    int ni() throws IOException { return Integer.parseInt(next()); }
    long nl() throws IOException { return Long.parseLong(next()); }
    
    int n,root,ct;
    ArrayList<Integer>[]A;
    int[]P,C,B,S;
  
    void solve() throws IOException {
        for (int tc=1;tc>0;tc--) {
            n=ni();
            A=new ArrayList[n+1];
            for (int i=0;i<=n;i++) A[i]=new ArrayList();
            P=new int[n+1];
            C=new int[n+1];
            for (int i=1;i<=n;i++) {
                P[i]=ni();
                C[i]=ni();
                if (P[i]==0) root=i;
                else A[P[i]].add(i);
            }
            
            B=new int[n+1];
            S=new int[n+1];
            ct=1;
            
            if (!dfs(root)) out.println("NO");
            else {
                out.println("YES");
                for (int i=1;i<=n;i++) out.print(B[i]+" ");
                out.println();
            }
            
        }
        out.flush();
    }
    
    boolean dfs(int u) {
        int curr=ct;
        S[u]=1;
        
        if (A[u].size()==0) {
            B[u]=ct;
            ct++;
            if (C[u]>0) return false;
            else return true;
        }
        
        for (Integer v:A[u]) {
            if (!dfs(v)) return false;
            S[u]+=S[v];
        }
        
        if (C[u]>=S[u]) return false;
        B[u]=curr+C[u];
        if (B[u]<ct) 
            for (Integer v:A[u]) update(v,B[u]);
        
        ct++;
        return true;
    }
    
    void update(int u,int w) {
        if (B[u]>=w) B[u]++;
        for (Integer v:A[u]) update(v,w);
    }
    
    public static void main(String[] args) throws IOException {
        new Main().solve();
    }
}