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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class A {
	static ArrayList<Integer> [] adj;
	static int [] x, dp [];
	static int mod = (int)1e9+7;
	public static void main(String[] args) throws NumberFormatException, IOException {
		Scanner sc = new Scanner();
		PrintWriter out = new PrintWriter(System.out);
		int n = sc.nextInt();
		adj = new ArrayList[n];
		for (int i = 0; i < adj.length; ++i) {
			adj[i] = new ArrayList<>();
		}
		for (int i = 0; i < n-1; ++i) {
			int u = sc.nextInt();
			adj[u].add(i+1);
			adj[i+1].add(u);
		}
		x = new int[n];
		for (int i = 0; i < x.length; ++i) {
			x[i] = sc.nextInt();
		}
		dp = new int[2][n];
		dfs(0, -1);
		out.println(dp[1][0]);
		out.close();
	}
	static void dfs(int u, int p) {
		dp[0][u] = 1;
		dp[1][u] = 0;
		for(int v:adj[u])
			if(v != p){
				dfs(v, u);
				dp[1][u] = mul(dp[1][u], dp[0][v]);
				dp[1][u] = add(dp[1][u], 1l*dp[0][u]*dp[1][v]);
				dp[0][u] = mul(dp[0][u], dp[0][v]);
			}
		if(x[u] == 1)
			dp[1][u] = dp[0][u];
		else dp[0][u] = add(dp[0][u], dp[1][u]);
	}
	static int add(long a, long b) {
		return (int) ((a + b) % mod);
	}
	static int mul(long a, long b) {
		return (int) ((a * b) % mod);
	}
	static class Scanner {
		BufferedReader br;
		StringTokenizer st;

		public Scanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens()) {
				st = new StringTokenizer(br.readLine());
			}
			return st.nextToken();
		}

		public int nextInt() throws NumberFormatException, IOException {
			return Integer.parseInt(next());
		}
	}

}