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
"""
5
1 1 1 1
1 -1 -1 -1 -1
"""


import sys
import bisect
import heapq
import math

INF = 10**9+7
sys.setrecursionlimit(INF)

def fi():
    return int(sys.stdin.readline())

def fi2():
    return map(int, sys.stdin.readline().split())

def fi3():
    return sys.stdin.readline()

def fo(*args):
    for s in args:
        sys.stdout.write(str(s)+' ')
    sys.stdout.write('\n')

##
parent = {1 : None}

def bfs():
    global G, a, s, parent
    

    level = {1 : 1}
    i = 2

    frt = [1]

    while frt:
        nxt = []
        for u in frt:
            for v in G[u]:
                if v not in parent:
                    parent[v] = u
                    level[v] = i
                    nxt.append(v)

                    if s[v] == -1:
                        a[v] = m(v) - s[parent[v]] ####

                    else:
                        a[v] = s[v] - (a[parent[v]]+s[parent[parent[v]]])

        frt = nxt
        i += 1

def m(u):
    global parent

    if len(G[u]) == 1:
        return s[parent[u]]
    
    res = INF
    for v in G[u]:
        if v == parent[u]:
            continue
        
        res = min(res, s[v])

    #print u, res
    return res

    
#main

n = fi()

G = {}
for u in range(1,n+1):
    G[u] = []

p = fi2()
for u in range(2, n+1):
    G[u].append(p[u-2])
    G[p[u-2]].append(u)

a = [-1 for i in range(n+1)]

s = fi2()
s.insert(0, 0)

a[1] = s[1]

bfs()

a[0] = 0

for i in a:
    if i < 0:
        fo(-1)
        exit(0)

res = sum(a)

fo(res)




    
    
