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
import java.util.*;
import java.io.*;
public class round263D {
    public static void main(String args[]) throws Exception{
        cf462D solve=new cf462D();
        solve.input();
        solve.dfs(-1,0);
        System.out.println(solve.dp[0][1]);
    }
}
class cf462D {
    final static int N=100005;
    final static long mod=1000000007;
    ArrayList<ArrayList<Integer>> g;
    public long dp[][]=new long[N][2];
    int color[]=new int [N];
    int next[]=new int [N];
    int n;
    public void input() throws Exception{
        //System.setIn(new BufferedInputStream(new FileInputStream("in.txt")));
        Scanner in=new Scanner(System.in);
        n=in.nextInt();
        g=new ArrayList<ArrayList<Integer>>();
        for(int i=0;i<n-1;i++) {
            next[i]=in.nextInt();
        }
        for(int i=0;i<n;i++) {
            color[i]=in.nextInt();
            g.add(new ArrayList<Integer>());
            Arrays.fill(dp[i],0);
        }
        for(int i=0;i<n-1;i++) {
            g.get(i+1).add(next[i]);
            g.get(next[i]).add(i+1);
        }
    }
    public void dfs(int f,int u) {
        dp[u][color[u]]=1;
        dp[u][color[u]^1]=0;
        ArrayList<Integer> tmp=g.get(u);
        for(Integer v:tmp) {
            if(v==f) continue;
            dfs(u,v);
            dp[u][1]=((((dp[v][0]+dp[v][1])%mod)*dp[u][1])%mod+dp[u][0]*dp[v][1])%mod;
            dp[u][0]=((dp[v][0]+dp[v][1])%mod)*dp[u][0]%mod;
        }
    }
}
