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 \ge 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 \le n \le 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 \le p_i < i$). The last line contains integer values $s_1$, $s_2$, ..., $s_n$ ($-1 \le s_v \le 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

```python

USER_FILENAME = "<user_code>"
import sys, json, builtins
import math, heapq, bisect, itertools, functools, collections, statistics, fractions, decimal, operator, array, random, re, string, os, pathlib
try:
    import resource as _res
except Exception:
    _res = None
from collections import Counter, defaultdict, deque, OrderedDict
from functools import lru_cache, reduce
from itertools import accumulate, permutations, combinations, product
from math import gcd, ceil, floor, sqrt
from decimal import Decimal
try:
    from typing import *
except Exception:
    pass
try:
    sys.setrecursionlimit(1_000_000)
except Exception:
    pass
try:
    import site as _site
    try:
        _sys_sites = _site.getsitepackages() if hasattr(_site, "getsitepackages") else []
        for _p in _sys_sites:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
    try:
        _usp = _site.getusersitepackages()
        if isinstance(_usp, str):
            _usp = [_usp]
        for _p in _usp:
            if _p and _p not in sys.path:
                sys.path.append(_p)
    except Exception:
        pass
except Exception:
    pass

ns = {"__name__": "__main__"}
for _k, _v in list(globals().items()):
    if not _k.startswith("_"):
        ns[_k] = _v
_CODE = "import sys\ninput=sys.stdin.readline\nimport collections\nfrom collections import defaultdict\nn=int(input())\npar=[ int(i) for i in input().split() if i!='\\n']\nsuma=[int(i) for i in input().split() if i!='\\n']\ngraph=defaultdict(list)\nfor i in range(n-1):\n    graph[i+2].append(par[i])\n    graph[par[i]].append(i+2)\n#print(graph)\nweight=[0]*(n+1)\nweight[1]=suma[0]\nqueue=collections.deque([1])\nvisited=set()\nvisited.add(1)\nok=True\nwhile queue:\n    vertex=queue.popleft()\n    for child in graph[vertex]:\n        if child not in visited: \n            if suma[child-1]==-1:\n                mina=[]\n                if len(graph[child])==1:\n                    mina=[0]\n                else:   \n                    for j in graph[child]:\n                        if j!=vertex:\n                            mina.append(suma[j-1]-suma[vertex-1])\n                ans=suma[vertex-1]+min(mina)\n                suma[child-1]=ans\n                if suma[child-1]<suma[vertex-1]:\n                    ok=False\n                else:\n                    weight[child]=(suma[child-1]-suma[vertex-1])\n            else:\n                if suma[child-1]<suma[vertex-1]:\n                    ok=False\n                else:\n                    weight[child]=(suma[child-1]-suma[vertex-1])\n            #print(child,vertex,weight,suma[child-1],suma[vertex-1])\n            queue.append(child)\n            visited.add(child)\n#print(weight,ok,suma)\nif ok==True:\n    print(sum(weight))\nelse:\n    print(-1)\n"
_co = compile(_CODE, USER_FILENAME, "exec")
exec(_co, ns, ns)

```

Measured memory_bytes: 14655