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
def solve():
    n = int(input())
    p = list(map(int, input().split(" ")))  # 2...n
    s = list(map(int, input().split(" ")))  # 1...n
    
    MAX_VAL = 10**9 + 2
    
    v_child = [None] * n  # 1...n
    
    for i, p_i in enumerate(p):
        idx = i + 1
    
        if v_child[p_i - 1]:
            v_child[p_i - 1].append(idx)
        else:
            v_child[p_i - 1] = [idx]
    
    
    def fill_s(v_idx, parent_s):
        if s[v_idx] == -1 and v_idx != 0:
            s_for_ch = parent_s
        else:
            s_for_ch = s[v_idx]
        if v_child[v_idx]:
            min_ch_s = MAX_VAL
            for ch_idx in v_child[v_idx]:
                ch_s = fill_s(ch_idx, s_for_ch)
                if 0 <= ch_s < min_ch_s:
                    min_ch_s = ch_s
    
            if s[v_idx] == -1:
                if min_ch_s != MAX_VAL:
                    s[v_idx] = min_ch_s
                else:
                    s[v_idx] = s_for_ch
            elif s[v_idx] > min_ch_s:
                # error
                raise ValueError("")
        elif s[v_idx] == -1 and v_idx != 0:
            s[v_idx] = parent_s
    
        return s[v_idx]
    
    
    def get_a(v_idx):
        p_idx = p[v_idx - 1] - 1
    
        if s[v_idx] == -1:
            if v_idx == 0 or s[p_idx] == -1:
                return 0
            s[v_idx] = s[p_idx]
    
        a = s[v_idx]
        if v_child[v_idx]:
            for ch_idx in v_child[v_idx]:
                ch_a = get_a(ch_idx)
                if ch_a < 0:
                    raise ValueError("")
                a += ch_a
        if v_idx > 0:
            a -= s[p_idx]
    
        return a
    
    
    try:
        fill_s(0, 0)
        # print(s)
        print(get_a(0))
    except Exception as e:
        print(-1)
        
from sys import setrecursionlimit
setrecursionlimit(2 * 10**5)
import threading
threading.stack_size(10**8)
t = threading.Thread(target=solve)
t.start()
t.join()