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.PrintStream;
import java.util.Arrays;
import java.util.Scanner;

/**
 * @author Roman Elizarov
 */
public class Round_263_B {
	public static void main(String[] args) {
		new Round_263_B().go();
	}

	static final int MOD = 1000000007;

	int n;
	int[] p;
	int[] c;

	void go() {
		// read input
		Scanner in = new Scanner(System.in);
		n = in.nextInt();
		p = new int[n];
		for (int i = 1; i < n; i++)
			p[i] = in.nextInt();
		c = new int[n];
		for (int i = 0; i < n; i++)
			c[i] = in.nextInt();

		// solve
		int result = solve();

		// write result
		PrintStream out = System.out;
		out.println(result);
	}

	int[] nChildren;
	int[][] children;

	int solve() {
		nChildren = new int[n];
		for (int i = 1; i < n; i++)
			nChildren[p[i]]++;
		children = new int[n][];
		for (int i = 0; i < n; i++) {
			children[i] = new int[nChildren[i]];
			nChildren[i] = 0;
		}
		for (int i = 1; i < n; i++)
			children[p[i]][nChildren[p[i]]++] = i;
		return subtree(0)[1];
	}

	private int[] subtree(int i) {
		int[] r;
		if (c[i] == 0) {
			if (nChildren[i] == 0)
				r = new int[] { 1, 0 };
			else {
				r = subtree(children[i][0]);
				r = new int[] {
					add(r[1], r[0]),
					r[1]
				};
				for (int k = 1; k < nChildren[i]; k++) {
					int[] s = subtree(children[i][k]);
					r = new int[] {
						add(mul(r[0], s[1]), mul(r[0], s[0])),
						add(mul(r[1], s[1]), mul(r[0], s[1]), mul(r[1], s[0]))
					};
				}
			}
		} else {
			// c[i] == 1
			if (nChildren[i] == 0)
				r = new int[] { 0, 1 };
			else {
				r = subtree(children[i][0]);
				r = new int[] {
					0,
					add(r[1], r[0]) };
				for (int k = 1; k < nChildren[i]; k++) {
					int[] s = subtree(children[i][k]);
					r = new int[] {
							0,
							add(mul(r[1], s[1]), mul(r[1], s[0]))
					};
				}
			}
		}
		return r;
	}

	int mul(long a, long b) {
		return (int)(a * b % MOD);
	}

	int add(long a, long b) {
		return (int)((a + b) % MOD);
	}

	int add(long a, long b, long c) {
		return (int)((a + b + c) % MOD);
	}
}
