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.*;
import java.math.BigInteger;

public class Main
{
    static final long mod=1000000007;
    static ArrayList<Integer>[] adj;
    static long[] value;
    static boolean f=true;
    public static void main(String[] args) throws Exception
    {
    	FastReader in=new FastReader();
    	PrintWriter pw=new PrintWriter(System.out);
    	int n=in.nextInt();
    	adj=new ArrayList[n+1];
    	value=new long[n+1];
    	for(int i=1;i<=n;i++)
    		adj[i]=new ArrayList<>();
    	for(int i=2;i<=n;i++)
    		adj[in.nextInt()].add(i);
    	for(int i=1;i<=n;i++)
    		value[i]=in.nextLong();
    	dfs(1,1,value[1]);
    	long ans=0;
    	for(int i=1;i<=n;i++)
    		ans+=value[i];
    	if(f)
    		pw.print(ans);
    	else
    		pw.print(-1);
    	pw.flush();
    }

    public static void dfs(int a,int h,long v)
    {
    	if(h%2==0)
    	{
    		long min=Long.MAX_VALUE;
    		for(int i:adj[a])
    			min=Math.min(min,value[i]-v);
    		if(min<0)
    		{
    			f=false;
    			return;
    		}
    		if(min==Long.MAX_VALUE)
    			min=0;
    		value[a]=min;
    		for(int i:adj[a])
    		{
    			value[i]-=v+value[a];
    			dfs(i,h+1,value[i]+v+value[a]);
    		}
    	}
    	else
    	{
    		for(int i:adj[a])
    		{
    			dfs(i,h+1,v);
    		}
    	}
    }
}

class FastReader
{
    BufferedReader br;
    StringTokenizer st;
 
    public FastReader()
    {
        br=new BufferedReader(new InputStreamReader(System.in));
    }
 
    public String next() throws IOException
    {
        if(st==null || !st.hasMoreElements())
        {
            st=new StringTokenizer(br.readLine());
        }
        return st.nextToken();
    }
 
    public int nextInt() throws IOException
    {
        return Integer.parseInt(next());
    }
 
    public long nextLong() throws IOException
    {
        return Long.parseLong(next());
    }
}