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.math.BigInteger;
import java.io.*;

public class Codeforces{
	
	static class Reader{
		final private int BUFFER_SIZE = 1 << 16;
		private DataInputStream din;
		private byte[] buffer;
		private int bufferPoint, bytesRead;
		
		public Reader(){
			din = new DataInputStream(System.in);
			buffer = new byte[BUFFER_SIZE];
			bufferPoint = bytesRead = 0;
		}
		
		public Reader(String fileName) throws IOException{
			din = new DataInputStream(new FileInputStream(fileName));
			buffer = new byte[BUFFER_SIZE];
			bufferPoint = bytesRead = 0;
		}
		
		public String readLine() throws IOException{
			byte[] buf = new byte[1000000];
			int cnt = 0, c;
			while((c = read()) != -1){
				if(c == '\n'){
					if(cnt == 0) continue;
					break;
				} 
				buf[cnt++] = (byte) c;
			}
			return new String(buf, 0, cnt).trim();
		}
		
		public String nn() throws IOException{
			byte[] buf = new byte[1000000];
			int cnt = 0, c;
			while((c = read()) != -1){
				if(c == ' ' || c == '\n'){
					if(cnt == 0) continue;
					break;
				} 
				buf[cnt++] = (byte) c;
			}
			return new String(buf, 0, cnt).trim();
		}
		
		public int ni() throws IOException{
			int ret = 0;
			byte c = read();
			while(c <= ' ') c = read();
			boolean neg = (c == '-');
			if(neg) c = read();
			do{
				ret = ret * 10 + c - '0';
			}while((c = read()) >= '0' && c <= '9');
			if(neg) return -ret;
			return ret;
		}
		
		public long nl() throws IOException{
			long ret = 0;
			byte c = read();
			while(c <= ' ') c = read();
			boolean neg = (c == '-');
			if(neg) c = read();
			do{
				ret = ret * 10 + c - '0';
			}while((c = read()) >= '0' && c <= '9');
			if(neg) return -ret;
			return ret;
		}
		
		public double nd() throws IOException{
			double ret = 0, div = 1;
			byte c = read();
			while(c <= ' ') c = read();
			boolean neg = (c == '-');
			if(neg) c = read();
			do{
				ret = ret * 10 + c - '0';
			}while((c = read()) >= '0' && c <= '9');
			if(c == '.'){
				while((c = read()) >= '0' && c <= '9'){
					ret += (c - '0') / (div *= 10);
				}
			}
			if(neg) return -ret;
			return ret;
		}
		
		private void fillBuffer() throws IOException{
			bytesRead = din.read(buffer, bufferPoint = 0, BUFFER_SIZE);
			if(bytesRead == -1) buffer[0] = -1;
		}
		
		private byte read() throws IOException{
			if(bufferPoint == bytesRead) fillBuffer();
			return buffer[bufferPoint++];
		}
		
		public void close() throws IOException{
			if(din == null) return;
			din.close();
		}
		
		public int[] niArr(int n) throws IOException{
			int[] ar = new int[n];
			for(int i = 0; i < n; i++) ar[i] = ni();
			return ar;
		}
	}
	
	public static <T> void mprint(T ... ar){
		for(T i: ar) out.print(i + " ");
	}
	
	private static PrintWriter out;
	
    public static void main(String[] args) throws IOException, CloneNotSupportedException{
		
		Reader sc = new Reader();
		out = new PrintWriter(new BufferedOutputStream(System.out));
		
		getAns(sc);
		
		sc.close();
		out.close();
    }
	
	private static void getAns(Reader sc) throws IOException{
		int n = sc.ni();
		ArrayList<Integer> list[] = new ArrayList[n + 1];
		for(int i = 1; i <= n; i++) list[i] = new ArrayList<>();
		for(int i = 2; i <= n; i++){
			int a = sc.ni();
			list[a].add(i);
		}
		
		// System.out.println(Arrays.toString(list));
		
		long[] s = new long[n + 1];
		for(int i = 1; i <= n; i++) s[i] = sc.nl();
		
		Queue<Node> queue = new LinkedList<>();
		
		queue.add(new Node(1, 0, 1));
		
		long ans = 0;
		
		while(!queue.isEmpty()){
			Node cur = queue.poll();
			if(cur.level % 2 == 0){
				long minVal = Long.MAX_VALUE;
				for(Integer i: list[cur.index]) minVal = Math.min(minVal, s[i]);
				if(minVal < cur.sumTillNow){out.println(-1); return;}
				for(Integer i: list[cur.index]) queue.add(new Node(i, minVal, cur.level + 1));
				if(minVal != Long.MAX_VALUE) ans += minVal - cur.sumTillNow;
			}else{
				if(cur.sumTillNow > s[cur.index]){out.println(-1); return;}
				ans += s[cur.index] - cur.sumTillNow;
				for(Integer i: list[cur.index]) queue.add(new Node(i, s[cur.index], cur.level + 1));
			}
		}
		
		out.println(ans);
	}
	
	static class Node{
		int index, level;
		long sumTillNow;
		Node(int index, long sumTillNow, int level){
			this.index = index;
			this.sumTillNow = sumTillNow;
			this.level = level;
		}
		
		public String toString(){
			return this.index + " " + this.sumTillNow + " " + this.level;
		}
	}
}