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 B461 {
	static ArrayList <Integer> [] g = new ArrayList [100010];
	static int color [] = new int [100010];
	final static int mod = 1000000007;
	static long [][] fn = new long [100010][2];

	static long modpower(long b, long e) {
		if(e == 0) return 1;
		if((e % 2) == 1) return (modpower(b, e - 1) * b) % mod;
		long m = modpower(b, e / 2);
		return (m * m) % mod;
	}
	static long inverse(long x) {
		return modpower(x, mod - 2);
	}

	static long dp(int x, int take) {
		if(fn[x][take] != -1) return fn[x][take];

		long perm = 1;
		for(Integer i : g[x]) {
			perm *= dp(i, 0) + dp(i, 1);
			perm %= mod;
		}
		long ans;

		if(color[x] == 1) {
			if(take == 1) ans = perm;
			else ans = 0;
		} else if (take == 0) {
			ans = perm;
		} else {
			ans = 0;
			for(Integer i : g[x]) {
				long r = (perm * inverse( dp(i, 0) + dp(i, 1) )) % mod;
				r *= dp(i, 1);
				r %= mod;
				ans += r;
				ans %= mod;
			}
		}
		return fn[x][take] = ans;
	}

	public static void main(String[] args) {
		Reader in = new Reader ();
		int n = in.nextInt();

		for(int i = 0; i <= n; i++) {
			for(int j = 0; j <= 1; j++) {
				fn[i][j] = -1;
			}
		}
		
		for(int i = 0; i <= n; i++) g[i] = new ArrayList <Integer> ();
		for(int i = 1; i < n; i++) {
			int p = in.nextInt();
			g[p].add(i);
		}
		for(int i = 0; i < n; i++) {
			color[i] = in.nextInt();
		}
		long ans = dp(0, 1);
		System.out.println(ans);	
	}

	static class Reader {
		BufferedReader a;
		StringTokenizer b;
		Reader () {
			a = new BufferedReader (new InputStreamReader (System.in));
		}
		String next () {
			while(b == null || !b.hasMoreTokens()) {
				try {
					b = new StringTokenizer (a.readLine());
				} catch (IOException e) {
					e.printStackTrace ();
				}
			}
			return b.nextToken ();
		}
		int nextInt () {
			return Integer.parseInt(this.next());
		}
	}
}