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 EdE    {
	static long[][] dp;
	static Map<Integer, ArrayList<Integer>> mp;
	static long num = 1000000007;
	public static void main(String[] args) throws Exception{

		// TODO Auto-generated method stub
 		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
 		PrintWriter out = new PrintWriter(System.out);
 		mp = new HashMap<Integer, ArrayList<Integer>>();
 		int n = Integer.parseInt(bf.readLine());
 		for(int j = 0;j<n;j++)
 			mp.put(j,  new ArrayList<Integer>());
 		StringTokenizer st = new StringTokenizer(bf.readLine());
 		for(int j =0 ;j<n-1;j++){
 			int v = Integer.parseInt(st.nextToken());
 			mp.get(j+1).add(v);
 			mp.get(v).add(j+1);
 		}
 		dp = new long[n][2]; // [0] means there is 0 black nodes in the subtree that includes that node,  [1] means ther eis 1 black node in the subtree that includes that node
 		StringTokenizer st1 = new StringTokenizer(bf.readLine());
 		for(int j =0 ;j<n;j++){
 			int bw = Integer.parseInt(st1.nextToken());
 			dp[j][0] = 1-bw;
 			dp[j][1] = bw;
 		}
 		dfs(0, -1);
 		
 		
 		
 		
 		out.println(dp[0][1]);
	 		
 		out.close();
 		
 		
 		
 	}
	public static void dfs(int v, int p){
		for(int child : mp.get(v)){
			if (child == p)
				continue;
			dfs(child, v);
			long zero = 0;
			long one = 0;
			zero+=dp[v][0]*dp[child][0];
			zero%=num;
			one+=dp[v][1]*dp[child][0];
			one%=num;
			one+=dp[v][0]*dp[child][1];
			one%=num;
			zero+=dp[v][0]*dp[child][1];
			zero%=num;
			one+=dp[v][1]*dp[child][1];
			one%=num;
			dp[v][0] = zero;
			dp[v][1] = one;
			
		}
			
	}
}
 	
 
//StringJoiner sj = new StringJoiner(" "); 
//sj.add(strings)
//sj.toString() gives string of those stuff w spaces or whatever that sequence is

 		
 		
 		
 		
	


