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 final int mod = 1000000007;
	static long[][] chart;

	public static void main(String[] args){
		Scan scan = new Scan();
		int n = scan.nextInt();
		ArrayList<Integer>[] list = new ArrayList[n];
		for(int i=0;i<n;i++) list[i] = new ArrayList<Integer>();
		boolean[] black = new boolean[n];
		for(int i=1;i<n;i++){
			int v = scan.nextInt();
			list[i].add(v);
			list[v].add(i);
		}
		for(int i=0;i<n;i++) black[i] = (scan.nextInt() == 1);

		chart = new long[n][2];
		long result = walk(0, list, black, -1);
		System.out.println(result);
	}

	static long walk(int root, ArrayList<Integer>[] list, boolean[] black, int parent){
		chart[root][0] = 1;
		chart[root][1] = 0;
		for(Integer in : list[root]){
			int next = in;
			if(parent == next) continue;
			walk(next, list, black, root);
			chart[root][1] *= chart[next][0];
			chart[root][1] += chart[root][0] * chart[next][1];
			chart[root][0] *= chart[next][0];
			chart[root][0] %= mod;
			chart[root][1] %= mod;
		}
		if(black[root]){
			chart[root][1] = chart[root][0];
		}else{
			chart[root][0] += chart[root][1];
		}
		chart[root][0] %= mod;
		chart[root][1] %= mod;
		return chart[root][1];
	}

}

class Scan implements Iterator<String>{

	BufferedReader buffer;
	StringTokenizer tok;

	Scan(){
		buffer = new BufferedReader(new InputStreamReader(System.in));
	}


	@Override
	public boolean hasNext(){
		while(tok == null || !tok.hasMoreElements()){
			try{
				tok = new StringTokenizer(buffer.readLine());
			}catch(Exception e){
				return false;
			}
		}
		return true;
	}

	@Override
	public String next(){
		if(hasNext()) return tok.nextToken();
		return null;
	}

	@Override
	public void remove(){
		throw new UnsupportedOperationException();
	}

	int nextInt(){
		return Integer.parseInt(next());
	}

	long nextLong(){
		return Long.parseLong(next());
	}

	String nextLine(){
		if(hasNext()) return tok.nextToken("\n");
		return null;
	}
}