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.lang.*;
import java.util.*;
import java.io.*;
public class Main {
    void solve() {
        int n=ni();
       g=new ArrayList[n+1];
       c=new int[n+1];
       int root=-1;
       for(int i=1;i<=n;i++) g[i]=new ArrayList<>();
       for(int i=1;i<=n;i++) {
           int p=ni();
           c[i]=ni();
           if(p==0){
               root=i;
               continue;
           }
           g[p].add(i);
           g[i].add(p);
       }
        check=true;
        dfs(root,-1);
        if(!check){
            pw.println("NO");
            return;
        }
        list=new ArrayList<>();
        for(int i=1;i<=n;i++) list.add(i);
        ans=new int[n+1];
        dfs2(root,-1);
        pw.println("YES");
        for(int i=1;i<=n;i++) pw.print(ans[i]+" ");
        pw.println("");
    }
    int ans[];
    int c[];
    boolean check;
    int dfs(int v,int pr){
        int cc=0;
        for(int u : g[v]){
            if(u!=pr) cc+=dfs(u,v);
        }
        if(cc<c[v])check=false;
        return cc+1;
    }
    ArrayList<Integer> list;
    void dfs2(int v,int pr){
        ans[v]=list.get(c[v]);
        list.remove(c[v]);
        for(int u : g[v]){
            if(u!=pr) dfs2(u,v);
        }
    }

    ArrayList<Integer> g[];
    class Node implements Comparable<Node> {
        int id;
        int a;
        int l;
        public Node(int id,int a,int l){
            this.id=id;
            this.a=a;
            this.l=l;
        }
        public int compareTo(Node c){
            int t=Integer.compare(this.a,c.a);
            if(t!=0) return t;
            return Integer.compare(this.l,c.l);
        }
    }


    long M = (long)1e9+7;
    // END
    PrintWriter pw;
    StringTokenizer st;
    BufferedReader br;

    void run() throws Exception {
        br = new BufferedReader(new InputStreamReader(System.in));
        pw = new PrintWriter(System.out);
        long s = System.currentTimeMillis();
        solve();
        pw.flush();
    }
    public static void main(String[] args) throws Exception {

        new Main().run();
    }

    String ns() {
        while (st == null || !st.hasMoreElements()) {

            try {
                st = new StringTokenizer(br.readLine());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return st.nextToken();
    }

    String nextLine() throws Exception {
        String str = "";
        try {
            str = br.readLine();
        } catch (IOException e) {
            throw new Exception(e.toString());
        }
        return str;
    }

    int ni() {
        return Integer.parseInt(ns());
    }

    long nl() {
        return Long.parseLong(ns());
    }

    double nd() {
        return Double.parseDouble(ns());
    }
}