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.*;

public class Main
{
	static long[] s;
	static long[] a;
	static MyList[] graph;

	public static void main(String[] args)
	{
		FastReader reader = new FastReader();
		PrintWriter writer = new PrintWriter(System.out);

		int n = reader.nextInt();
		graph = new MyList[n];
		a = new long[n];
		s = new long[n];

		for (int i=0; i<n; i++)
			graph[i] = new MyList();

		for (int i=1; i<n; i++)
			graph[reader.nextInt()-1].list.add(i);

		for (int i=0; i<n; i++)
			s[i] = reader.nextLong();

		a[0] = s[0];
		for (int i : graph[0].list)
			dfs(0, i, 2);

		boolean exists = true;
		long ans = 0;

		for (int i=0; i<n; i++)
		{
			ans += a[i];

			if (a[i] < 0)
				exists = false;
		}

		if (exists)
			writer.println(ans);
		else
			writer.println(-1);

		writer.close();
	}

	static void dfs(int p, int u, int h)
	{
		if (h%2 == 1)
			a[u] = s[u] - s[p];
		else
			if (graph[u].list.size() > 0)
			{
				long low = Long.MAX_VALUE;

				for (int v : graph[u].list)
					low = Math.min(low, s[v]);

				a[u] = low - s[p];
				s[u] = low;
			}

		for (int v : graph[u].list)
			dfs(u, v, h+1);
	}

	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();
		}

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

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

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

		String nextLine()
		{
			String str = "";
			try
			{
				str = br.readLine();
			}
			catch (IOException e)
			{
				e.printStackTrace();
			}
			return str;
		}
	}
}

class MyList
{
	ArrayList<Integer> list = new ArrayList<>();
}