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.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.*;

import javax.swing.text.InternationalFormatter;

import java.math.*;

import org.omg.CORBA.Any;

public class template {

	static long time = 0, mp = Integer.MAX_VALUE, k = 0, cnt = 0;;

	static int[] parent;
	static int[] low;
	static int[] des;
	static boolean[] aps;
	static ArrayList<Integer>[] a;
	static String sb = "";

	public static void main(String[] args) throws IOException {

		Reader scn = new Reader();
		int n=scn.nextInt();
		
		int []par=new int[n+1];
		int []sum=new int[n+1];
		
		par[1]=-1;
		
		for(int i=2; i<par.length; i++)
			par[i]=scn.nextInt();
		
		for(int i=1; i<sum.length; i++)
			sum[i]=scn.nextInt();
		
		cnt=sum[1];
		
		ArrayList<Integer>[]g=new ArrayList[n+1];
		
		for(int i=1; i<g.length; i++)
			 g[i]=new ArrayList<Integer>();
		
		for(int i=2; i<par.length; i++){
			g[i].add(par[i]);
			g[par[i]].add(i);
		}
		
		
		boolean b =dfs(1,g,par,sum, new HashSet<Integer>(), 1);
		
		if(!b)
			System.out.println(-1);
		else
		System.out.println(cnt);
		
	}

	// _________________________TEMPLATE_____________________________________________________________

	private static boolean dfs(int v, ArrayList<Integer>[] g, int[] par, int[] sum, HashSet<Integer> visited, int depth) {

		if (g[v].size() == 1 && g[v].get(0)==par[v])
			return true;

		visited.add(v);

		

		if (depth % 2 == 0){
			int psum = sum[par[v]], pnbr = Integer.MAX_VALUE;
			
			for (int nbr : g[v]) {

                 if(nbr!=par[v]){
					
                      pnbr=Math.min(pnbr, sum[nbr]);
					 if (pnbr < psum)
                 		return false;
                 }

			}
			
			int sv=pnbr-psum;
					
			for(int nbr : g[v]){
				
				if(nbr != par[v]){
				int ad=sum[nbr]-(sv+psum);
				cnt+=sum[nbr]-(sv+psum);
				}
			}
			
			cnt+=sv;
		}
		
		
		for(int nbr:g[v]){
			 if(!visited.contains(nbr)){
				boolean b= dfs(nbr, g, par, sum, visited, depth+1);
				if(!b)
					return b;
			 }
		}
		
		return true;
	}

	static class pair implements Comparable<pair> {
		int v;
		int w;
		// int cnt;

		pair(int b, int a) {
			v = b;
			w = a;
			// cnt = x;
		}

		@Override
		public int compareTo(pair o) {

			return this.v - o.v;
		}
	}

	// -----------PrintWriter for faster output---------------------------------
	public static PrintWriter out;

	public static class Reader {
		final private int BUFFER_SIZE = 1 << 16;
		private DataInputStream din;
		private byte[] buffer;
		private int bufferPointer, bytesRead;

		public Reader() {
			din = new DataInputStream(System.in);
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}

		public Reader(String file_name) throws IOException {
			din = new DataInputStream(new FileInputStream(file_name));
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}

		public String readLine() throws IOException {
			byte[] buf = new byte[100000 + 1]; // line length
			int cnt = 0, c;
			while ((c = read()) != -1) {
				if (c == '\n')
					break;
				buf[cnt++] = (byte) c;
			}
			return new String(buf, 0, cnt);
		}

		public int nextInt() 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 nextLong() 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 nextDouble() 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, bufferPointer = 0, BUFFER_SIZE);
			if (bytesRead == -1)
				buffer[0] = -1;
		}

		private byte read() throws IOException {
			if (bufferPointer == bytesRead)
				fillBuffer();
			return buffer[bufferPointer++];
		}

		public void close() throws IOException {
			if (din == null)
				return;
			din.close();
		}

		public int[] nextIntArray(int n) throws IOException {
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = nextInt();
			}
			return arr;
		}

		public long[] nextLongArray(int n) throws IOException {
			long[] arr = new long[n];
			for (int i = 0; i < n; i++) {
				arr[i] = nextLong();
			}
			return arr;
		}

		public int[][] nextInt2DArray(int m, int n) throws IOException {
			int[][] arr = new int[m][n];
			for (int i = 0; i < m; i++) {
				for (int j = 0; j < n; j++)
					arr[i][j] = nextInt();
			}
			return arr;
		}

	}

	// private static void rem(HashMap<Integer, Integer> hm) {
	//
	// Iterator<Map.Entry<Integer, Integer>> itr = hm.entrySet().iterator();
	// ArrayList<Integer> p=new ArrayList<>();
	//
	//
	// while(itr.hasNext()){
	// Map.Entry<Integer, Integer> entry = itr.next();
	// p.add(entry.getKey());
	//
	// }
	//
	//
	// for(int i:p){
	//
	// if(hm.get(i)>1)
	// hm.put(i, hm.get(i)-1);
	// else
	// hm.remove(i);
	// }
	// }

}
