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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.StringTokenizer;

public class Z530D {
    static BufferedReader _in = new BufferedReader(new InputStreamReader(System.in));
    static StringTokenizer _stk;
    static String next() {
        try {
            while (_stk == null || !_stk.hasMoreTokens())
                _stk = new StringTokenizer(_in.readLine());

            return _stk.nextToken();
        } catch(Exception ex) {
            throw new RuntimeException("Failed reading input", ex);
        }
    }
    static int nextInt() { return Integer.parseInt(next()); }
    static long nextLong() { return Long.parseLong(next()); }
    static double nextDouble() { return Double.parseDouble(next()); }

    public static void main(String [] args) throws IOException {
        int N = nextInt();
        nodes = new Node[N];
        for(int i=0; i<N; i++) nodes[i] = new Node();

        for(int i=1; i<N; i++) {
            int parent = nextInt()-1;
            nodes[parent].children.add(nodes[i]);
        }

        for(int i=0; i<N; i++) {
            nodes[i].sum = nextInt();
        }

        nodes[0].fillLevel(1);

        if(!nodes[0].assignSum(0)) {
            System.out.println(-1);
            return;
        }

        if(!nodes[0].assignVal(0)) {
            System.out.println(-1);
            return;
        }

        long total = nodes[0].sumOfValues();
        System.out.println(total);
    }

    static Node[] nodes;

    static class Node {
        LinkedList<Node> children = new LinkedList<>();
        int val = -1;
        int sum = -1;
        int lvl = -1;

        void fillLevel(int l) {
            lvl = l;
            for(Node ch: children)
                ch.fillLevel(l+1);
        }

        boolean assignSum(int parentSum) {
            if(sum==-1) {
                int minChildrenSum = Integer.MAX_VALUE;
                for(Node ch : children) {
                    minChildrenSum = Math.min(minChildrenSum, ch.sum);
                }

                if(minChildrenSum==Integer.MAX_VALUE) {
                    minChildrenSum = parentSum;
                }

                if(minChildrenSum<parentSum) {
                    return false;
                }

                sum = minChildrenSum;
            }

            for(Node ch: children) {
                if(!ch.assignSum(sum))
                    return false;
            }

            return true;
        }

        boolean assignVal(int parentSum) {
            val = sum-parentSum;
            if(val<0) return false;

            for(Node ch: children) {
                if(!ch.assignVal(sum))
                    return false;
            }

            return true;
        }

        long sumOfValues() {
            long total = val;
            for(Node ch: children)
                total += ch.sumOfValues();

            return total;
        }
    }
}