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.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;


public class CF1287D {
	
	   int ok = 1;
	   int[] c = new int[3000];
	   List<Integer>[] g;
	   List<Integer>[] h;
	   
	   void dfs(int x, int fa) {
		  // System.out.println(x);
		   for (int t: g[x]) {
			   if (t == fa) continue;
			   dfs(t, x);
			   h[x].addAll(h[t]);			   
		   }
		   if (c[x] > h[x].size()) ok = 0;
		   if (ok > 0) h[x].add(c[x], x);
	   }
	   
	   void solve() {
	        InputStream inputStream = System.in;
	        OutputStream outputStream = System.out;
	        InputReader in = new InputReader(inputStream);
	        PrintWriter out = new PrintWriter(outputStream);
	        int n = in.nextInt(), root = 0;
	        g = new ArrayList[n + 1]; 
	        h = new ArrayList[n + 1];
	        c = new int[3000];
	        for (int i = 1; i <= n; i ++) {
	        	g[i] = new ArrayList<Integer>();
	        	h[i] = new ArrayList<Integer>();
	        }
	        for (int i = 1; i <= n; i ++) {        	
	        	int p = in.nextInt();
	        	c[i] = in.nextInt();
	        	if (p > 0) g[p].add(i); else root = i;
	        }
	        dfs(root, 0);
	        int[] ans = new int[n + 1];
	        if (ok > 0) {
	        	out.println("YES");
	        	int num = 0;
	        	for (int t: h[root]) ans[t] = ++ num;
	        	for (int i = 1; i <= n; i ++) out.print(ans[i] + " ");
	        } else out.println("NO");
	        out.close();
	   }
	   
	   public static void main(String args[]) {
		   new CF1287D().solve();
	   }
	   
	   static class InputReader {
	        public BufferedReader reader;
	        public StringTokenizer tokenizer;
	 
	        public InputReader(InputStream stream) {
	            reader = new BufferedReader(new InputStreamReader(stream), 32768);
	            tokenizer = null;
	        }
	 
	        public String next() {
	            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
	                try {
	                    tokenizer = new StringTokenizer(reader.readLine());
	                } catch (IOException e) {
	                    throw new RuntimeException(e);
	                }
	            }
	            return tokenizer.nextToken();
	        }
	        
	        public int nextInt() {
	            return Integer.parseInt(next());
	        }
	 
	    }
}
