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
#include <bits/stdc++.h>
const int maxn = 200010;
const int inf = 0x3f3f3f3f;
int n;
int a[maxn];
int s[maxn];
int par[maxn];
bool indeg[maxn];
template <class t>
t max(t a, t b) {
  return a > b ? a : b;
}
template <class t>
t min(t a, t b) {
  return a < b ? a : b;
}
struct Node {
  int to;
  int ne;
};
Node node[maxn << 2];
int head[maxn];
int top;
void add(int from, int to) {
  node[top].to = to;
  node[top].ne = head[from];
  head[from] = top;
  top++;
}
void ini() {
  top = 0;
  memset(head, -1, sizeof(head));
}
bool check() {
  for (int i = 1; i <= n; ++i) {
    if (indeg[i] == false) {
      int now = i;
      int val = max(s[now], s[par[now]]);
      while (now != -1) {
        if (s[now] == -1) {
          now = par[now];
          continue;
        }
        if (val < s[now]) return false;
        val = s[now];
        now = par[now];
      }
    }
  }
  return true;
}
void dfs(int now = 1, long long pref = 0) {
  int min_son = inf;
  for (int i = head[now]; i != -1; i = node[i].ne) {
    int nxt = node[i].to;
    min_son = min(min_son, s[nxt]);
  }
  if (s[now] == -1) {
    s[now] = min_son;
    if (s[now] == inf) s[now] = pref;
  }
  a[now] = s[now] - pref;
  for (int i = head[now]; i != -1; i = node[i].ne) {
    int nxt = node[i].to;
    dfs(nxt, pref + a[now]);
  }
}
long long calc() {
  dfs();
  long long ret = 0;
  for (int i = 1; i <= n; ++i) {
    ret += a[i];
  }
  return ret;
}
void init() {
  ini();
  memset(indeg, false, sizeof(indeg));
  memset(par, 0, sizeof(par));
  memset(a, 0, sizeof(a));
  par[1] = -1;
}
int main() {
  while (~scanf("%d", &n)) {
    init();
    for (int i = 2; i <= n; ++i) {
      scanf("%d", par + i);
      indeg[par[i]] = true;
      add(par[i], i);
    }
    for (int i = 1; i <= n; ++i) {
      scanf("%d", s + i);
    }
    if (check()) {
      printf("%I64d\n", calc());
    } else {
      printf("-1\n");
    }
  }
  return 0;
}
