Appleman has a tree with n vertices. Some of the vertices (at least one) are colored black and other vertices are colored white.

Consider a set consisting of k (0 ≤ k < n) edges of Appleman's tree. If Appleman deletes these edges from the tree, then it will split into (k + 1) parts. Note, that each part will be a tree with colored vertices.

Now Appleman wonders, what is the number of sets splitting the tree in such a way that each resulting part will have exactly one black vertex? Find this number modulo 1000000007 (109 + 7).

Input

The first line contains an integer n (2 ≤ n ≤ 105) — the number of tree vertices. 

The second line contains the description of the tree: n - 1 integers p0, p1, ..., pn - 2 (0 ≤ pi ≤ i). Where pi means that there is an edge connecting vertex (i + 1) of the tree and vertex pi. Consider tree vertices are numbered from 0 to n - 1.

The third line contains the description of the colors of the vertices: n integers x0, x1, ..., xn - 1 (xi is either 0 or 1). If xi is equal to 1, vertex i is colored black. Otherwise, vertex i is colored white.

Output

Output a single integer — the number of ways to split the tree modulo 1000000007 (109 + 7).

Examples

Input

3
0 0
0 1 1


Output

2


Input

6
0 1 1 0 4
1 1 0 0 1 0


Output

1


Input

10
0 1 2 1 4 4 4 0 8
0 0 0 1 0 1 1 0 0 1


Output

27
# by the authority of GOD     author: manhar singh sachdev #

import os,sys
from io import BytesIO,IOBase

def main():
    mod = 10**9+7
    n = int(input())
    path = [[] for _ in range(n)]
    for ind,i in enumerate(map(int,input().split())):
        path[i].append(ind+1)
        path[ind+1].append(i)
    col = list(map(int,input().split()))
    dp = [[1,0] for _ in range(n)]
    for i in range(n):
        dp[i][col[i]] = 1
        dp[i][col[i]^1] = 0
    # number of ways to construct subtree
    # no black vertex ; one black vertex
    st,poi,visi = [0],[0]*n,[1]+[0]*(n-1)
    while len(st):
        x,y = st[-1],path[st[-1]]
        if poi[x] != len(y) and visi[y[poi[x]]]:
            poi[x] += 1
        if poi[x] == len(y):
            if not col[st.pop()]:
                dp[x][1] = (dp[x][1]*dp[x][0])%mod
            if len(st):
                if col[st[-1]]:
                    dp[st[-1]][0] = 0
                    dp[st[-1]][1] = (dp[st[-1]][1]*sum(dp[x]))%mod
                else:
                    dp[st[-1]][0] = (dp[st[-1]][0]*sum(dp[x]))%mod
                    dp[st[-1]][1] = (dp[st[-1]][1]+dp[x][1]*pow(sum(dp[x]),mod-2,mod))%mod
        else:
            i = y[poi[x]]
            st.append(i)
            visi[i] = 1
            poi[x] += 1
    print(dp[0][1])

# Fast IO Region
BUFSIZE = 8192
class FastIO(IOBase):
    newlines = 0
    def __init__(self,file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None
    def read(self):
        while True:
            b = os.read(self._fd,max(os.fstat(self._fd).st_size,BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0,2),self.buffer.write(b),self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()
    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd,max(os.fstat(self._fd).st_size,BUFSIZE))
            self.newlines = b.count(b"\n")+(not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0,2),self.buffer.write(b),self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()
    def flush(self):
        if self.writable:
            os.write(self._fd,self.buffer.getvalue())
            self.buffer.truncate(0),self.buffer.seek(0)
class IOWrapper(IOBase):
    def __init__(self,file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s:self.buffer.write(s.encode("ascii"))
        self.read = lambda:self.buffer.read().decode("ascii")
        self.readline = lambda:self.buffer.readline().decode("ascii")
sys.stdin,sys.stdout = IOWrapper(sys.stdin),IOWrapper(sys.stdout)
input = lambda:sys.stdin.readline().rstrip("\r\n")
if __name__ == "__main__":
    main()