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.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.InputMismatchException;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;
 
                     
                     
                     
                     
                     
                    public class Solution1 implements Runnable
                    {
                        static final long MOD = 1000000007;
                        static class InputReader
                        {
                            private InputStream stream;
                            private byte[] buf = new byte[1024];
                            private int curChar;
                            private int numChars;
                            private SpaceCharFilter filter;
                            private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
                     
                            public InputReader(InputStream stream)
                            {
                                this.stream = stream;
                            }
                            
                            public int read()
                            {
                                if (numChars==-1) 
                                    throw new InputMismatchException();
                                
                                if (curChar >= numChars)
                                {
                                    curChar = 0;
                                    try 
                                    {
                                        numChars = stream.read(buf);
                                    }
                                    catch (IOException e)
                                    {
                                        throw new InputMismatchException();
                                    }
                                    
                                    if(numChars <= 0)                
                                        return -1;
                                }
                                return buf[curChar++];
                            }
                         
                            public String nextLine()
                            {
                                String str = "";
                                try
                                {
                                    str = br.readLine();
                                }
                                catch (IOException e)
                                {
                                    e.printStackTrace();
                                }
                                return str;
                            }
                            public int nextInt()
                            {
                                int c = read();
                                
                                while(isSpaceChar(c)) 
                                    c = read();
                                
                                int sgn = 1;
                                
                                if (c == '-') 
                                {
                                    sgn = -1;
                                    c = read();
                                }
                                
                                int res = 0;
                                do 
                                {
                                    if(c<'0'||c>'9') 
                                        throw new InputMismatchException();
                                    res *= 10;
                                    res += c - '0';
                                    c = read();
                                }
                                while (!isSpaceChar(c)); 
                                
                                return res * sgn;
                            }
                            
                            public long nextLong() 
                            {
                                int c = read();
                                while (isSpaceChar(c))
                                    c = read();
                                int sgn = 1;
                                if (c == '-') 
                                {
                                    sgn = -1;
                                    c = read();
                                }
                                long res = 0;
                                
                                do 
                                {
                                    if (c < '0' || c > '9')
                                        throw new InputMismatchException();
                                    res *= 10;
                                    res += c - '0';
                                    c = read();
                                }
                                while (!isSpaceChar(c));
                                    return res * sgn;
                            }
                            
                            public double nextDouble() 
                            {
                                int c = read();
                                while (isSpaceChar(c))
                                    c = read();
                                int sgn = 1;
                                if (c == '-') 
                                {
                                    sgn = -1;
                                    c = read();
                                }
                                double res = 0;
                                while (!isSpaceChar(c) && c != '.') 
                                {
                                    if (c == 'e' || c == 'E')
                                        return res * Math.pow(10, nextInt());
                                    if (c < '0' || c > '9')
                                        throw new InputMismatchException();
                                    res *= 10;
                                    res += c - '0';
                                    c = read();
                                }
                                if (c == '.') 
                                {
                                    c = read();
                                    double m = 1;
                                    while (!isSpaceChar(c)) 
                                    {
                                        if (c == 'e' || c == 'E')
                                            return res * Math.pow(10, nextInt());
                                        if (c < '0' || c > '9')
                                            throw new InputMismatchException();
                                        m /= 10;
                                        res += (c - '0') * m;
                                        c = read();
                                    }
                                }
                                return res * sgn;
                            }
                            
                            public String readString() 
                            {
                                int c = read();
                                while (isSpaceChar(c))
                                    c = read();
                                StringBuilder res = new StringBuilder();
                                do 
                                {
                                    res.appendCodePoint(c);
                                    c = read();
                                } 
                                while (!isSpaceChar(c));
                                
                                return res.toString();
                            }
                         
                            public boolean isSpaceChar(int c) 
                            {
                                if (filter != null)
                                    return filter.isSpaceChar(c);
                                return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
                            }
                         
                            public String next() 
                            {
                                return readString();
                            }
                            
                            public interface SpaceCharFilter 
                            {
                                public boolean isSpaceChar(int ch);
                            }
                        }
                         
                        public static void main(String args[]) throws Exception
                        {
                            new Thread(null, new Solution1(),"Solution",1<<26).start();
                        }   
                        static long gcd(long a, long b) 
                        { 
                          if (b == 0) 
                            return a; 
                          return gcd(b, a % b);  
                        } 
                        static long lcm(long a,long b) {
                            return (a*b)/gcd(a,b);
                        }
                        ArrayList<Integer> adj[];
                        @SuppressWarnings("unchecked")
						public void run() 
                        {
                            InputReader sc = new InputReader(System.in);
                            PrintWriter w = new PrintWriter(System.out);
                            int n = sc.nextInt();
                            adj = new ArrayList[n];
                            for(int i = 0;i < n;i++) {
                            	adj[i] = new ArrayList();
                            }
                            for(int i = 1;i < n;i++) {
                            	int a = sc.nextInt()-1;
                            	adj[a].add(i);
                            	adj[i].add(a);
                            }
                             valu = new long[n];
                            for(int i = 0;i < n;i++) {
                            	valu[i] = sc.nextLong();
                            }
                            bfs(0);
                            for(int i = 0;i < level.length;i++) {
                            	if(level[i] % 2 == 0) {
                            		long min = Long.MAX_VALUE;
                            		Iterator<Integer> it = adj[i].iterator();
                            		while(it.hasNext()) {
                            			int x = it.next();
                            			if(x != parent[i]) {
                            				min = Math.min(min,valu[x] - valu[parent[i]]);
                            			}
                            		}
                            		if(min == Long.MAX_VALUE) {
                            			val[i] = 0;
                            		}else if(min < 0) {
                            			w.println("-1");
                            			w.close();
                            			System.exit(0);
                            		}
                            		else {
                            			val[i] = min;
                            		}
                            	}
                            }
                            for(int i = 1;i < level.length;i++) {
                            	if(level[i] % 2 != 0) {
                            		val[i] = valu[i] - valu[parent[parent[i]]] - val[parent[i]];
                            	}
                            }
                            long ans = 0;
                            for(int i = 0;i < level.length;i++) {
                            	ans += val[i];
                            }
                            w.println(ans);
                            w.close();
                        }
                        long[] valu;
                        int[] depth;
                        long[] val;
                        int[] level;
                        int[] parent;
                        void bfs(int curr) {
                        	Queue<Integer> q = new LinkedList();
                        	q.add(curr);
                        	boolean[] visited = new boolean[adj.length];
                        	visited[curr] = true;
                        	val = new long[adj.length];
                        	val[curr] = valu[0];
                        	level = new int[adj.length];
                        	level[curr] = 1;	
                        	parent = new int[adj.length];
                        	while(!q.isEmpty()) {
                        		int x = q.poll();
                        		Iterator<Integer> it = adj[x].iterator();
                        		while(it.hasNext()) {
                        			int u = it.next();
                        			if(!visited[u]) {
                        				parent[u] = x;
                        				level[u] = level[x] + 1;
                        				visited[u] = true;
                        				q.add(u);
                        				
                         			}
                        		}
                        		
                        	}
                        }
                        long nCr(int a,int b) {
                            long one = fact[a];
                            long two = (fact[b] * fact[a - b]) % MOD;
                            long three = (one * power(two,MOD-2,MOD)) % MOD;
                            return three;
                        }
                        static long power(long a,long b,long mod) {
                            long ans = 1;
                            a = a % mod;
                            while(b != 0) {
                                if(b % 2 == 1) {
                                    ans = (ans * a) % mod;
                                }
                                a = (a * a) % mod;
                                b = b/2;
                            }
                            return ans;
                        }
                        long[] fact = new long[1000005];
                        void pre() {
                            fact[0] = 1;
                            for(int i = 1;i < fact.length;i++) {
                                fact[i] = (fact[i-1] * i) % MOD;
                            }
                        }
                        
                        class Pair implements Comparable<Pair>{
                            long a;
                            long b;
                            
                            Pair(long a,long b){
                                this.b = b;
                                this.a = a;
                               
                            }
                            public boolean equals(Object o) {
                                Pair p = (Pair)o;
                                return this.a == p.a && this.b == this.b;
                            }
                            public int hashCode(){
                                return Long.hashCode(a)*27 + Long.hashCode(b)*31;
                            }
                            public int compareTo(Pair p) {
                            	if(this.a == p.a) {
                            		return Long.compare(this.b,p.b);
                            	}
                                return Long.compare(this.a,p.a);
                            }
                        }
                        
                    }