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
// package Quarantine;

import javafx.util.Pair;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class AppleManAndTree {
    public static void main(String[] args)throws IOException {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        int n=Integer.parseInt(br.readLine());
        ArrayList<Integer> tree[]=new ArrayList[n];
        for(int i=0;i<n;i++){
            tree[i]=new ArrayList<>();
        }
        StringTokenizer st=new StringTokenizer(br.readLine());
        for(int i=0;i<=n-2;i++){
            int x=Integer.parseInt(st.nextToken());
            tree[i+1].add(x);
            tree[x].add(i+1);
        }
        int val[]=new int[n];
        st=new StringTokenizer(br.readLine());
        for(int i=0;i<n;i++){
            val[i]=Integer.parseInt(st.nextToken());
        }
        long ans[]=dfs(tree,0,new boolean[n],val,1000000007);
        System.out.println(ans[1]);
    }
    public static long[] dfs(ArrayList<Integer> tree[],int curr,boolean visited[],int val[],int mod){
        long ans[]=new long[2];
        visited[curr]=true;
        if(val[curr]==1){
            ans[1]=1;
            for(int j:tree[curr]){
                if(!visited[j]){
                    long small[]=dfs(tree,j,visited,val,mod);
                    ans[1]=(ans[1]*(small[0]+small[1]))%mod;
                }
            }
        }
        else{
            ans[0]=1;
            ArrayList<Pair<Long,Long>> temp=new ArrayList<>();
            for(int j:tree[curr]){
                if(!visited[j]){
                    long small[]=dfs(tree,j,visited,val,mod);
                    ans[0]=(ans[0]*(small[0]+small[1]))%mod;
                    temp.add(new Pair<>(small[0],small[1]));
                }
            }
            for(Pair<Long,Long> p:temp){
                long t=(p.getValue()*ans[0])%mod;
                t=(t*modexp(p.getValue()+p.getKey(),mod-2,mod))%mod;
                ans[1]=(ans[1]+t)%mod;
            }
        }
        return ans;
    }
    public static long modexp(long a,long power,int mod){
        if(power==0){
            return 1;
        }
        if(power==1){
            return a;
        }
        long small=modexp(a,power/2,mod);
        long ans=(small%mod*small%mod)%mod;
        if(power%2!=0){
            ans=(ans%mod*a%mod)%mod;
        }
        return ans;
    }
}
