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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.InputStream;
 
/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        ASumInTheTree solver = new ASumInTheTree();
        solver.solve(1, in, out);
        out.close();
    }
 
    static class ASumInTheTree {
        static ArrayList<Integer>[] arrl;
 
        public void solve(int testNumber, Scanner sc, PrintWriter pw) {
            int n = sc.nextInt();
            arrl = new ArrayList[n];
            int[] p = new int[n];
            p[0] = 0;
            for (int i = 0; i < n; i++) arrl[i] = new ArrayList<Integer>();
            for (int i = 1; i < n; i++) {
                int x = sc.nextInt();
                arrl[x - 1].add(i);
                p[i] = x - 1;
            }
            int[] w = new int[n];
            int[] sum = new int[n];
            int[] tmp = new int[n];
            long ans = 0;
            for (int i = 0; i < n; i++) {
                tmp[i] = sc.nextInt();
                w[i] = tmp[i] == -1 ? w[p[i]] : tmp[i];
 
            }
            // pw.println(Arrays.toString(w));
            boolean[] vis = new boolean[n];
            w = modified(w, p);
            // pw.println(Arrays.toString(w));
            if (check(0, w, w[0], vis, p)) {
                for (int i = 0; i < n; i++) {
                    if (i == 0) sum[i] = tmp[i];
                    else {
                        sum[i] = (w[i] - (w[p[i]]) == 0) ? 0 : w[i] - (w[p[i]]);
                    }
                    ans += 1l * sum[i];
                }
                pw.println(ans);
            } else {
                pw.println(-1);
            }
            pw.flush();
        }
 
        public static boolean check(int p, int[] w, int max, boolean[] vis, int[] pa) {
            vis[p] = true;
            if (w[p] < w[pa[p]]) return false;
            boolean res = true;
            for (int x : arrl[p]) {
                if (!vis[x])
                    res&= check(x, w, Math.max(max, w[x]), vis, pa);
            }
            return res;
        }
 
        public static int[] modified(int[] w, int[] p) {
            int[] res = new int[w.length];
            int[] min = new int[w.length];
            Arrays.fill(min, Integer.MAX_VALUE);
            for (int i = 0; i < w.length; i++) {
                res[i] = w[i];
                min[p[i]] = Math.min(min[p[i]], w[i]);
            }
            for (int i = 0; i < w.length; i++) {
                res[i] = Math.max(res[i], min[i] == Integer.MAX_VALUE ? 0 : min[i]);
            }
            return res;
        }
 
    }
 
    static class Scanner {
        StringTokenizer st;
        BufferedReader br;
 
        public Scanner(FileReader r) {
            br = new BufferedReader(r);
        }
 
        public Scanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }
 
        public String next() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return st.nextToken();
        }
 
        public int nextInt() {
            return Integer.parseInt(next());
        }
 
    }
}