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

public class ProblemD {

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        Scanner sc = new Scanner(System.in);
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

        int nodosN = sc.nextInt();
        Node[] nodos = new Node[nodosN];
        Node[] nodosOri = new Node[nodosN];
        nodos[0] = new Node();
        nodos[0].parent = -1;
        for (int i = 1; i < nodosN; i++) {
            nodos[i] = new Node();
            nodos[i].parent = sc.nextInt()-1;
        }
        long topValue = -1;
        for (int i = 0; i < nodosN; i++) {
            nodos[i].pathToRoot = sc.nextInt();
            topValue = Math.max(topValue,nodos[i].pathToRoot);
            nodos[i].maxVal = Integer.MAX_VALUE/2;
            nodos[i].nodeNum = i;
            nodosOri[i] = nodos[i];
        }

        Arrays.sort(nodos,(o1, o2) -> {
            return Long.compare(o1.parent,o2.parent);
        });
        boolean possible = true;
        for (int i = nodosN-1; i > 0; i--) {
            if (nodos[i].pathToRoot!=-1) {
                if (nodos[i].maxVal < nodos[i].pathToRoot) {
                    possible = false;
                    break;
                }
                    nodos[i].maxVal = Math.min(nodos[i].maxVal,nodos[i].pathToRoot);
                nodosOri[nodos[i].parent].maxVal = Math.min(nodosOri[nodos[i].parent].maxVal, nodos[i].pathToRoot);
            } else if (nodos[i].maxVal!=Integer.MAX_VALUE/2){
                nodosOri[nodos[i].parent].maxVal = Math.min(nodosOri[nodos[i].parent].maxVal, nodos[i].maxVal);
            }
        }
        if (possible) {
            if (nodos[0].maxVal<nodos[0].pathToRoot){
                possible = false;
            }
        }
        if(possible){
            nodosOri[0].acc = nodos[0].pathToRoot;
            long sum = nodos[0].pathToRoot;
            for (int i = 1; i < nodosN; i++) {
                long acc = nodosOri[nodos[i].parent].acc;

                if(nodos[i].maxVal==Integer.MAX_VALUE/2)continue;

                long usedHere = (nodos[i].maxVal-acc);

                sum += usedHere;

                nodos[i].acc = acc + usedHere;
            }
            bw.write(sum+"\n");
        } else {
            bw.write("-1\n");
        }
        bw.flush();
        bw.close();
    }

    static class Node {
        public long  maxVal,pathToRoot;
        public int parent;
        public long leftToUse, acc;
        public long nodeNum;
    }
}
