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

import static java.lang.Math.*;

public class sum_in_the_tree implements Runnable {

  long mod = 1000000000 + 7;
  /*
   * less than return 1 => large number first;
   */
  class Node{
    long height = -1;
    long value = -1;
    long sum = -1;
    ArrayList<Integer> children = new ArrayList();
  }

  Node[] arr;
  boolean is_possible = true;
  public void run() {
    InputReader in = new InputReader(System.in);
    PrintWriter out = new PrintWriter(System.out);

    int n = in.nextInt();
    arr = new Node[n+1];

    for(int i=0;i<=n;i++) arr[i] = new Node();

    for(int i=2;i<=n;i++){
      int p = in.nextInt();
      arr[p].children.add(i);
    }

    for(int i=1;i<=n;i++){
      long s = in.nextInt();
      arr[i].sum = s;
    }

    arr[1].value = arr[1].sum;

    recurse(1, out);

    if(is_possible){
      long total = 0; 
      for(int i=1;i<=n;i++) total+=arr[i].value;
      out.println(total);
    }else{
      out.println(-1);
    }

    // for(int i=1;i<=n;i++){
    //   out.println("value:"+arr[i].value+" sum:"+arr[i].sum);
    // }
    out.close();
  }

  void recurse(int current,PrintWriter out){
    Queue<Integer> q = new LinkedList(); 
    for(Integer i : arr[current].children){
      if(arr[i].children.size() > 0){
        long temp = Long.MAX_VALUE;
        for(Integer j: arr[i].children){
          if( (arr[j].sum - arr[current].sum) >= 0) temp = Math.min(temp, arr[j].sum - arr[current].sum);
          else {
            is_possible = false;
            return;
          }
          q.add(j);
        }
        arr[i].value = temp;
        for(Integer j: arr[i].children){
          arr[j].value = arr[j].sum - arr[current].sum - arr[i].value;
        }
      }else{
        arr[i].value = 0;
      }
    }

    while(!q.isEmpty()){
      recurse(q.poll(), out);
    }
  }

  long log2(long a) {
    return (long) (Math.log(a) / Math.log(2));
  }

  public long modAdd(long a, long b) {
    return (a % mod + b % mod) % mod;
  }

  public long modSub(long a, long b) {
    return ((a % mod - b % mod) % mod);
  }

  public long modMul(long a, long b) {
    return ((a % mod) * (b % mod)) % mod;
  }

  public long modDiv(long a, long b) {
    return ((a % mod) * (binaryExp(b, mod - 2))) % mod;
  }

  public long modPow(long a) {
    return a % (mod - 1);
  }

  public long binaryExp(long a, long pow) {
    a = a % mod;
    if (pow == 0) {
      return 1;
    } else if (pow == 1) {
      return a;
    } else {
      long half = pow / 2;
      long temp = binaryExp(a, half);
      if (pow % 2 == 0) {
        return (temp * temp) % mod;
      } else {
        return ((a % mod) * ((temp * temp) % mod)) % mod;
      }
    }
  }

  public static void main(String args[]) throws Exception {
    new Thread(null, new sum_in_the_tree(), "Main", 1 << 27).start();
  }

  static class InputReader {
    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;
    private SpaceCharFilter filter;
    private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    public InputReader(InputStream stream) {
      this.stream = stream;
    }

    public int read() {
      if (numChars == -1)
        throw new InputMismatchException();

      if (curChar >= numChars) {
        curChar = 0;
        try {
          numChars = stream.read(buf);
        } catch (IOException e) {
          throw new InputMismatchException();
        }

        if (numChars <= 0)
          return -1;
      }
      return buf[curChar++];
    }

    public String nextLine() {
      String str = "";
      try {
        str = br.readLine();
      } catch (IOException e) {
        e.printStackTrace();
      }
      return str;
    }

    public int nextInt() {
      int c = read();

      while (isSpaceChar(c))
        c = read();

      int sgn = 1;

      if (c == '-') {
        sgn = -1;
        c = read();
      }

      int res = 0;
      do {
        if (c < '0' || c > '9')
          throw new InputMismatchException();
        res *= 10;
        res += c - '0';
        c = read();
      } while (!isSpaceChar(c));

      return res * sgn;
    }

    public long nextLong() {
      int c = read();
      while (isSpaceChar(c))
        c = read();
      int sgn = 1;
      if (c == '-') {
        sgn = -1;
        c = read();
      }
      long res = 0;

      do {
        if (c < '0' || c > '9')
          throw new InputMismatchException();
        res *= 10;
        res += c - '0';
        c = read();
      } while (!isSpaceChar(c));
      return res * sgn;
    }

    public double nextDouble() {
      int c = read();
      while (isSpaceChar(c))
        c = read();
      int sgn = 1;
      if (c == '-') {
        sgn = -1;
        c = read();
      }
      double res = 0;
      while (!isSpaceChar(c) && c != '.') {
        if (c == 'e' || c == 'E')
          return res * Math.pow(10, nextInt());
        if (c < '0' || c > '9')
          throw new InputMismatchException();
        res *= 10;
        res += c - '0';
        c = read();
      }
      if (c == '.') {
        c = read();
        double m = 1;
        while (!isSpaceChar(c)) {
          if (c == 'e' || c == 'E')
            return res * Math.pow(10, nextInt());
          if (c < '0' || c > '9')
            throw new InputMismatchException();
          m /= 10;
          res += (c - '0') * m;
          c = read();
        }
      }
      return res * sgn;
    }

    public String readString() {
      int c = read();
      while (isSpaceChar(c))
        c = read();
      StringBuilder res = new StringBuilder();
      do {
        res.appendCodePoint(c);
        c = read();
      } while (!isSpaceChar(c));

      return res.toString();
    }

    public boolean isSpaceChar(int c) {
      if (filter != null)
        return filter.isSpaceChar(c);
      return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    public String next() {
      return readString();
    }

    public interface SpaceCharFilter {
      public boolean isSpaceChar(int ch);
    }
  }

}