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

public class Main {
	
	static ArrayList<Integer>[] adj;
	static ArrayList<Integer> all ;
	static int[] color; 
	static int n ;
	static boolean[] marked;
	static int start;
	static final long MOD = 1000000007;
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MyScanner sc = new MyScanner();
		
		n = sc.nextInt();
		all = new ArrayList<Integer>();
		adj = (ArrayList<Integer>[] )new ArrayList[n];
		color = new int[n];
		
		for(int i = 0 ; i < n ; ++i )
			adj[i] = new ArrayList<Integer>();
		
		int temp;
		for(int i = 1; i <= n-1 ; ++i )
		{
			temp = sc.nextInt();
			adj[i].add(temp) ; 
			adj[temp].add(i);
		}
		
		for(int i = 0 ; i < n  ; ++i )
			color[i] = sc.nextInt();
		
		
		
		System.out.println( dfs(0,-1).dp1 );
	}
	
	static pair dfs(int x , int parent )
	{
		pair temp = null;
		long dp0,dp1;
		
		
		//cout("Setting " + x );
			
			if( color[x] == 1 )
				{
				dp0 = 0;
				dp1 = 1;
				}
			
			else 
				{
				dp0 = 1;
				dp1 = 0;
				}
			
	
		
		
		
			
		
		for(int i : adj[x] )
		{
			if( i == parent ) continue;
			
			temp = dfs( i , x );
			dp1 = (dp1*temp.dp0 + dp0*temp.dp1 + dp1*temp.dp1)%MOD;
			
			dp0 = (dp0 * temp.dp0 + dp0*temp.dp1)%MOD;
		}
			

		
		//cout("For " + x +" : " + dp0 + "," + dp1);
		return new pair(dp0,dp1);
	}

	static class pair
	{
		long dp0 ,dp1 ;
		pair( long u , long v )
		{
			this.dp0 = u ;
			this.dp1 = v; 
		}
	}
	
	static void cout(Object o)
	{
		System.out.println( o );
	}
	static class MyScanner {
	      BufferedReader br;
	      StringTokenizer st;
	 
	      public MyScanner() {
				br = new BufferedReader( new InputStreamReader(System.in) ,8*1024);
	      }
	 
	      String next() {
	          while (st == null || !st.hasMoreElements()) {
	              try {
	                  st = new StringTokenizer(br.readLine());
	              } catch (IOException e) {
	                  e.printStackTrace();
	              }
	          }
	          return st.nextToken();
	      }
	 
	      int nextInt() {
	          return Integer.parseInt(next());
	      }
	 
	      long nextLong() {
	          return Long.parseLong(next());
	      }
	 
	      double nextDouble() {
	          return Double.parseDouble(next());
	      }
	 
	      String nextLine(){
	          String str = "";
		  try {
		     str = br.readLine();
		  } catch (IOException e) {
		     e.printStackTrace();
		  }
		  return str;
	      }

	   }

}

/*
 
 3
 0 0
 0 1 1
 
 -----2---------
 
 6
 0 1 1 0 4
 1 1 0 0 1 0
 
 ----1----------
 
 10
 0 1 2 1 4 4 4 0 8
 0 0 0 1 0 1 1 0 0 1
 
 ----27--------------
 
 */
