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 p1098A
{
    static LinkedList<Integer>[] list;
    static long[] s;
    public static void main(String[] args) throws IOException
    {
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        int n = Integer.parseInt(f.readLine());
        list = new LinkedList[n];
        s = new long[n];

        for(int i = 0; i < n; i++)
            list[i] = new LinkedList<>();

        st = new StringTokenizer(f.readLine());
        for(int v = 1; v < n; v++)
        {
            int u = Integer.parseInt(st.nextToken()) - 1;
            list[u].add(v);
            list[v].add(u);
        }

        st = new StringTokenizer(f.readLine());
        for(int i = 0; i < n; i++)
            s[i] = Integer.parseInt(st.nextToken());

        System.out.println(dfs(0, -1));
    }

    public static long dfs(int u, int p)
    {
        long result = 0;
        long minS = Long.MAX_VALUE;
        for(int v : list[u])
        {
            if(v == p)
                continue;
            if(s[u] == -1 && s[v] < s[p])
                return -1;
            minS = Math.min(minS, s[v]);

            int vp = u;
            while(list[v].size() == 2)
            {
                Iterator<Integer> iter = list[v].iterator();
                int v1 = iter.next();
                int v2 = iter.next();
                if(s[v] == -1 && s[v1 != vp ? v1 : v2] < s[vp])
                    return -1;

                int temp = v;
                v = v1 != vp ? v1 : v2;
                vp = temp;

            }
            if(list[v].size() == 1)
            {
                if(s[v] != -1)
                    result += s[v];
                else
                    result += s[list[v].getFirst()];
            }
            else
            {
                long call = dfs(v, vp);
                if(call == -1)
                    return -1;
                result += call;
            }
        }

        int size = u == 0 ? list[u].size() - 1 : list[u].size() - 2;
        if(s[u] == -1)
            return result - size * Math.max(minS, p == -1 ? 0 : s[p]);

        if(p != -1 && s[u] < s[p])
            return -1;
        return result - size * s[u];
    }
}
