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.*;


public class B {	
	BufferedReader reader;
    StringTokenizer tokenizer;
    PrintWriter out;

    int MOD = (int) 1e9 + 7;
    int N;
    ArrayList<Integer>[] childs;
    long[] blacks;
    long[] whites;
    int[] X;
	public void solve() throws IOException {				
		N = nextInt();
        childs = new ArrayList[N];
		for (int i = 0; i < N; i++) {
            childs[i] = new ArrayList<Integer>();
        }
        for (int i = 1; i < N; i++) {
            childs[nextInt()].add(i);
        }
        X = new int[N];
        for (int i = 0; i < N; i++) {
            X[i] = nextInt();
        }

        blacks = new long[N];
        whites = new long[N];

        dfs(0);
        out.println(blacks[0]);
	}

    public void dfs(int cur) {
        if (X[cur] == 1) {
            blacks[cur] = 1;
        } else {
            whites[cur] = 1;
        }

        for (int v: childs[cur]) {
            dfs(v);

            long new_black = 0;
            long new_white = 0;

            new_black += blacks[v] * blacks[cur];
            new_white += blacks[v] * whites[cur];
            new_black += blacks[v] * whites[cur];
            new_black += whites[v] * blacks[cur];
            new_white += whites[v] * whites[cur];

            blacks[cur] = new_black % MOD;
            whites[cur] = new_white % MOD;
        }
    }
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		new B().run();
	}
	
	public void run() {
        try {
            reader = new BufferedReader(new InputStreamReader(System.in));
            tokenizer = null;
            out = new PrintWriter(System.out);
            solve();
            reader.close();
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }

    int nextInt() throws IOException {
        return Integer.parseInt(nextToken());
    }

    long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }

    String nextToken() throws IOException {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            tokenizer = new StringTokenizer(reader.readLine());
        }
        return tokenizer.nextToken();
    }

}
