Mitya has a rooted tree with n vertices indexed from 1 to n, where the root has index 1. Each vertex v initially had an integer number a_v ≥ 0 written on it. For every vertex v Mitya has computed s_v: the sum of all values written on the vertices on the path from vertex v to the root, as well as h_v — the depth of vertex v, which denotes the number of vertices on the path from vertex v to the root. Clearly, s_1=a_1 and h_1=1.

Then Mitya erased all numbers a_v, and by accident he also erased all values s_v for vertices with even depth (vertices with even h_v). Your task is to restore the values a_v for every vertex, or determine that Mitya made a mistake. In case there are multiple ways to restore the values, you're required to find one which minimizes the total sum of values a_v for all vertices in the tree.

Input

The first line contains one integer n — the number of vertices in the tree (2 ≤ n ≤ 10^5). The following line contains integers p_2, p_3, ... p_n, where p_i stands for the parent of vertex with index i in the tree (1 ≤ p_i < i). The last line contains integer values s_1, s_2, ..., s_n (-1 ≤ s_v ≤ 10^9), where erased values are replaced by -1.

Output

Output one integer — the minimum total sum of all values a_v in the original tree, or -1 if such tree does not exist.

Examples

Input


5
1 1 1 1
1 -1 -1 -1 -1


Output


1


Input


5
1 2 3 1
1 -1 2 -1 -1


Output


2


Input


3
1 2
2 -1 1


Output


-1
import java.util.*;
import java.io.*;
import java.math.*;
 
public class Main
{
    public static void process(int test_number)throws IOException
    {
        int n = ni(), par[] = new int[n + 1], s[] = new int[n + 1], val[] = new int[n + 1],
            ht[] = new int[n + 1];
        ArrayList<Integer> l[] = new ArrayList[n + 1];
        for(int i = 1; i <= n; i++)
            l[i] = new ArrayList<>();

        for(int i = 2; i <= n; i++){
            par[i] = ni();
            l[i].add(par[i]);
            l[par[i]].add(i);
        }

        for(int i = 1; i <= n; i++)
            s[i] = ni();

        ht[1] = 1;
        val[1] = s[1];
        boolean isConsistent = true;
        Queue<Integer> q = new LinkedList<>();
        q.add(1);
        while(!q.isEmpty() && isConsistent){
            int node = q.poll();
            if((ht[node] & 1) == 0){

                // Leaf node 
                if(l[node].size() <= 1){
                    val[node] = 0;
                    continue;
                }

                int take = oo;
                for(int adj : l[node]){
                    if(adj == par[node])
                        continue;

                    take = Math.min(take, s[adj]);
                }

                if(take < s[par[node]]){
                    isConsistent = false;
                } else{
                    val[node] = take - s[par[node]];
                    for(int adj : l[node]){
                        if(adj == par[node])
                            continue;

                        val[adj] = s[adj] - val[node] - s[par[node]];
                        ht[adj] = 1 + ht[node];
                        q.add(adj);
                    }
                }
            } else{
                for(int adj : l[node]){
                    if(adj == par[node])
                        continue;

                    ht[adj] = 1 + ht[node];
                    q.add(adj);
                }
            }
        }

        if(isConsistent){ 
            long res = 0l;
            for(int x : val){
                res += (x * 1l);
            }
            pn(res);
        } else{
            pn("-1");
        } 
    }
    
    static final int oo = (int) 1e9 + 100;
    static final long mod = (long)1e9+7l;
    static boolean DEBUG = true;
    static FastReader sc;
    static PrintWriter out;
    public static void main(String[]args)throws IOException
    {
        out = new PrintWriter(System.out);
        sc = new FastReader();
 
        long s = System.currentTimeMillis();
        int t = 1;
        // t = ni();
        for(int i = 1; i <= t; i++)
            process(i);
 
        out.flush();
        System.err.println(System.currentTimeMillis()-s+"ms");
    }

    static void trace(Object... o){ if(!DEBUG) return; System.err.println(Arrays.deepToString(o)); };    
    static void pn(Object o){ out.println(o); }
    static void p(Object o){ out.print(o); }
    static int ni()throws IOException{ return Integer.parseInt(sc.next()); }
    static long nl()throws IOException{ return Long.parseLong(sc.next()); }
    static double nd()throws IOException{ return Double.parseDouble(sc.next()); }
    static String nln()throws IOException{ return sc.nextLine(); }
    static long gcd(long a, long b){ return (b==0)?a:gcd(b,a%b);}
    static int gcd(int a, int b){ return (b==0)?a:gcd(b,a%b); }
    
    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(); 
        } 
  
        String nextLine(){ 
            String str = ""; 
            try{ str = br.readLine(); } catch (IOException e) { e.printStackTrace(); } 
            return str; 
        } 
    } 
}
