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.*;
import java.util.*;
public class Main {
    public static void main(String args[])
    {
        FastReader input=new FastReader();
        PrintWriter out=new PrintWriter(System.out);
        int T=1;
        while(T-->0)
        {
            int n=input.nextInt();
            int arr[]=new int[n+1];
            ArrayList<Integer> adj[]=new ArrayList[n+1];
            ArrayList<Integer> a[]=new ArrayList[n+1];
            Vertex V[]=new Vertex[n+1];
            for(int i=1;i<=n;i++)
            {
                adj[i]=new ArrayList<>();
                a[i]=new ArrayList<>();
                V[i]=new Vertex(i);
            }
            int r=0;
            for(int i=1;i<=n;i++)
            {
                int v=input.nextInt();
                if(v!=0)
                {
                    adj[i].add(v);
                    adj[v].add(i);
                }
                else
                {
                    r=i;
                }
                arr[i]=input.nextInt();
            }
            ArrayList<Integer> list=new ArrayList<>();
            bfs(adj,V,r,list);
            int flag=0;
            for(int i=list.size()-1;i>=0;i--)
            {
                int u=list.get(i);
                for(int j=0;j<adj[u].size();j++)
                {
                    int v=adj[u].get(j);
                    if(u==r || v!=V[u].parent.key)
                    {
                        a[u].addAll(a[v]);
                    }
                }
                if(a[u].size()==0)
                {
                    if(arr[u]>0)
                    {
                        flag=1;
                        break;
                    }
                    a[u].add(u);
                }
                else
                {
                    if(arr[u]>a[u].size())
                    {
                        flag=1;
                        break;
                    }
                    a[u].add(arr[u],u);
                }
            }
            if(flag==1)
            {
                out.println("NO");
            }
            else
            {
                out.println("YES");
                int ar[]=new int[n+1];
                for(int i=0;i<a[r].size();i++)
                {
                    int u=a[r].get(i);
                    ar[u]=(i+1);
                }
                for(int i=1;i<=n;i++)
                {
                    out.print(ar[i]+" ");
                }
            }
        }
        out.close();
    }
    public static void bfs(ArrayList<Integer> adj[],Vertex V[], int s,ArrayList<Integer> list)
    {
        V[s].color="gray";
        V[s].d=0;
        V[s].parent=null;
        Queue<Integer> q=new LinkedList<>();
        q.add(s);
        list.add(s);
        while(!q.isEmpty())
        {
            int k=q.poll();
            Vertex u=V[k];
            for(int i=0;i<adj[k].size();i++)
            {
                int key=adj[k].get(i);
                Vertex v=V[key];
                if(v.color=="white")
                {
                    q.add(key);
                    list.add(key);
                    v.color="gray";
                    v.d=u.d+1;
                    v.parent=u;
                }
            }
            u.color="black";
        }
    }
    public static class Vertex
    {
        int key;
        int d,f;
        String color;
        Vertex parent;
        Vertex(int key)
        {
            this.key=key;
            this.d=0;
            this.f=0;
            this.color="white";
            this.parent=null;
        }
    }
    static class FastReader
    {
        BufferedReader br;
        StringTokenizer st;

        public FastReader()
        {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {

            return Long.parseLong(next());
        }

        double nextDouble()
        {

            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }
}