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
/*
If you want to aim high, aim high
Don't let that studying and grades consume you
Just live life young
******************************
If I'm the sun, you're the moon
Because when I go up, you go down
*******************************
READ THE PROBLEM (didn't notice all missing nodes had even depth)

*/
import java.util.*;
import java.io.*;

   public class x1098A
   {
      public static void main(String args[]) throws Exception
      {
         BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));  
         StringTokenizer st = new StringTokenizer(infile.readLine());
         int N = Integer.parseInt(st.nextToken());
         LinkedList<Integer>[] edges = new LinkedList[N+1];
         for(int i=1; i <= N; i++)
            edges[i] = new LinkedList<Integer>();
         st = new StringTokenizer(infile.readLine());
         for(int i=2; i <= N; i++)
         {
            int par = Integer.parseInt(st.nextToken());
            edges[par].add(i);
            edges[i].add(par);
         }
         int[] arr = new int[N+1];
         st = new StringTokenizer(infile.readLine());
         for(int i=0; i < N; i++)
            arr[i+1] = Integer.parseInt(st.nextToken());
         //solve 1 indexed
         int[] parent = new int[N+1];
         parent[1] = -1;
         dfs1(1, parent, edges);
         for(int i=2; i <= N; i++)
            if(arr[i] == -1)
            {
               //retrieve parent
               int par = parent[i];
               int min = Integer.MAX_VALUE;
               for(int next: edges[i])
                  if(next != par)
                     min = Math.min(min, arr[next]);
               if(min < arr[par])
               {
                  System.out.println(-1);
                  return;
               }
               if(min != Integer.MAX_VALUE)
                  arr[i] = min;
               else
                  arr[i] = arr[par];
            }
         long res = 0L;
         for(int i=1; i <= N; i++)
            for(int j: edges[i])
               if(parent[j] == i)
                  res += arr[j]-arr[i];
         res += arr[1];
         System.out.println(res);
      }
      public static void dfs1(int curr, int[] p, LinkedList<Integer>[] edges)
      {
         for(int next: edges[curr])
            if(p[next] == 0)
            {
               p[next] = curr;
               dfs1(next, p, edges);
            }
      }
   }