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.*;
import java.util.*;

public class D {

	static StringBuilder st = new StringBuilder();

	static int[] h;
	static ArrayList<Integer>[] adjList;
	static int n;

	static int[] s;
	static int[] par;
	static final int INF = (int) 1e9;

	static int pre() {
		Arrays.fill(h, INF);

		Queue<Integer> q = new LinkedList<>();
		h[0] = 0;
		q.add(0);
		int max = 0;
		while (!q.isEmpty()) {
			int node = q.poll();

			for (int v : adjList[node])
				if (h[v] > h[node] + 1) {
					h[v] = h[node] + 1;
					q.add(v);
					max = Math.max(max, h[v]);
				}
		}

		return max;

	}

	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);

		n = sc.nextInt();

		h = new int[n];
		par = new int[n];

		adjList = new ArrayList[n];

		for (int i = 0; i < n; i++)
			adjList[i] = new ArrayList<>();

		s = new int[n];
		int [] a = new int [n] ; 
		for (int i = 1; i < n; i++) {
			int x = sc.nextInt() - 1;
			par[i] = x;
			adjList[x].add(i);
			adjList[i].add(x);
		}

		for (int i = 0; i < n; i++)
			s[i] = sc.nextInt();
		
		a[0] = s[0] ; 
		
		
		int depth = pre() + 1;
		ArrayList<Integer>[] lvls = new ArrayList[depth];
		
		for (int i = 0; i < depth; i++)
			lvls[i] = new ArrayList<>();

		
		for (int i = 0; i < n; i++)
			if (h[i] != -1) {
				
				lvls[h[i]].add(i);
			}
			else {
				System.out.println(-1);
				return ; 
			}
		
		long ans = 0 ;
		
		for(int curr = 1 ; curr < depth ; curr += 2)
		{
			
			for(int u : lvls[curr])
			{
				int p = par[u] ; 
				
				boolean isLeaf = true ; 
				int minDiff = Integer.MAX_VALUE; 
				int sumParent = s[p] ; 
			
				for(int v : adjList[u])
					if(v != p)
					{
						isLeaf = false ;
						minDiff = Math.min(minDiff, s[v] - sumParent);
					}
				if(minDiff < 0)
				{
					System.out.println(-1);
					return ; 
				}
				if(isLeaf)
				{
					a[u] = 0 ; 
					continue ; 
				}
				
				a[u] = minDiff ; 	
				for(int v : adjList[u])
					if(v != p)
						a[v] = (s[v] - sumParent) - minDiff ; 
					
				
				
				
			}
		}
		for(int x : a)
			ans += x ; 
		
		System.out.println(ans);
		
		
		
		out.flush();
		out.close();

	}

	static class Scanner {
		BufferedReader br;
		StringTokenizer st;

		Scanner(InputStream in) {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() throws Exception {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());

			return st.nextToken();
		}

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

		long nextLong() throws Exception {
			return Long.parseLong(next());
		}

		double nextDouble() throws Exception {
			return Double.parseDouble(next());
		}

	}

	static void shuffle(int[] a) {
		int n = a.length;
		for (int i = 0; i < n; i++) {
			int r = i + (int) (Math.random() * (n - i));
			int tmp = a[i];
			a[i] = a[r];
			a[r] = tmp;
		}
	}

}