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.*;
import java.math.*;

public class B263{
    
    static int n;
    static int st[] = new int[100111];
    static boolean vs[] = new boolean [100111];
    static final int mod = 1000000007;
    static long f1[] = new long[100111], f0[] = new long[100111];
    
    public static class note{
        public ArrayList<Integer> e = new ArrayList<Integer>();
    }
    
    static note V[] = new note [100111];
    
    static void dfs(int u){
//      System.out.println("visting" + u);
        vs[u] = true;
        for(int v: V[u].e){
            if(!vs[v]){
                if(!vs[v]) dfs(v);
                if(st[u] == 0){
                    f1[u] = (f1[u] * ( f0[v] + f1[v]) % mod) % mod; //already had a black note
                    f1[u] = (f1[u] + (f0[u] * f1[v]) % mod) % mod; // connect the edge to get a black note
                    f0[u] = (f0[u] * ( f0[v] + f1[v])) % mod;
                    
                }
                else{
                    f1[u] = (f1[u] * (f0[v] + f1[v]) % mod) % mod;
                }
            }
        }
    }
    
    public static void main(String args[]){
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        for(int i = 0; i <= n; i++) V[i] = new note();
        for(int u = 1; u < n; u++){
            int v = sc.nextInt();
            V[u].e.add(v);
            V[v].e.add(u);
        }
        for(int i = 0; i < n; i++) {
            st[i] = sc.nextInt();
            if(st[i] == 1) f1[i] = 1;
            else f0[i] = 1;
        }
        dfs(0);
//      System.out.println(f1[1] + " " + f0[1]); 
        System.out.print(f1[0]);
    }
}
