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.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
import java.util.stream.Collectors;

public class Main {

	public static boolean accept = true;

	class Node {
		public Integer index;
		public Node parent;
		public List<Node> childrens;
		public Long current;
		public Long sum;
		public Integer depth;

		public Node() {
		}

		@Override
		public String toString() {
			StringBuilder builder = new StringBuilder();
			List<Integer> list = new ArrayList<Integer>();
			if (childrens != null)
				list = childrens.stream().map(node -> node.index).collect(Collectors.toList());
			Integer parentId = (parent != null) ? parent.index : -1;
			builder.append("[" + index + "] Parent -> " + parentId + " Childrens -> " + Arrays.toString(list.toArray())
					+ "\tCurrent -> " + current + "\tSum -> " + sum);
			return builder.toString();
		}
	}

	public static Long sum(Node node) {
		if (node.current < 0) {
			Main.accept = false;
		}
		Long total = node.current;
		for (int i = 0; i < node.childrens.size(); i++) {
			Node child = node.childrens.get(i);
			total += Main.sum(child);
		}
		return total;
	}
	public static void calculate(Node node) {
		if (node.depth % 2 == 1) {
			if (node.parent != null)
				node.current = node.sum - node.parent.sum;
			for (Node child : node.childrens) {
				calculate(child);
			}
		} else {
			if (node.childrens.isEmpty() && node.parent != null)
				node.sum = node.parent.sum;
			else {
				Long min = Long.MAX_VALUE;
				for (Node child : node.childrens)
					min = Math.min(min, child.sum);
				node.sum = min;
				for (Node child : node.childrens)
					calculate(child);
			}
			node.current = node.sum - node.parent.sum;
		}
	}

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();

		Main.Node[] nodes = new Main.Node[n];
		nodes[0] = (new Main().new Node());
		nodes[0].parent = null;
		nodes[0].childrens = new ArrayList<Node>();
		nodes[0].depth = 1;
		nodes[0].index = 0;

		for (int i = 1; i < n; i++) {
			int parent = scanner.nextInt();
			nodes[i] = (new Main().new Node());
			nodes[i].index = i;
			if (nodes[i].childrens == null)
				nodes[i].childrens = new ArrayList<Node>();
			nodes[i].parent = nodes[parent - 1];
			nodes[i].depth = nodes[parent - 1].depth + 1;
			nodes[parent - 1].childrens.add(nodes[i]);
		}

		nodes[0].current = scanner.nextLong();
		nodes[0].sum = nodes[0].current;
		for (int i = 1; i < n; i++) {
			Long sum = scanner.nextLong();
			nodes[i].sum = sum;
			nodes[i].current = new Long(-1);
		}

		Main.calculate(nodes[0]);

//		for (int i = 0; i < n; i++)
//			System.out.println(nodes[i]);

		Long sum = Main.sum(nodes[0]);
		if (Main.accept) System.out.println(sum);
		else System.out.println(-1);
		
		scanner.close();
	}
}