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.awt.Point;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.HashMap;

public class B {
    static int[] P;
    static int[] C;
    static HashMap<Point, Long> DP[];
    static ArrayList<Integer>[] E;
    static int mod = (int) 1e9 + 7;

    public static long get(int vertex, int index, int color) {
        if (color > 1)
            return 0;
        if (index >= E[vertex].size())
            return color == 0 ? 1 : 0;
        if (E[vertex].get(index) == P[vertex])
            return get(vertex, index + 1, color);
        Point temp = new Point(vertex, index);
        if (DP[color].containsKey(temp))
            return DP[color].get(temp);
        int current = E[vertex].get(index);
        P[current] = vertex;
        long ans = -1;
        if (color == 0) {
            if (C[current] == 0) {
                ans = (get(current, 0, 1) * get(vertex, index + 1, 0)) % mod;
                ans = (ans + (get(current, 0, 0) * get(vertex, index + 1, 0))
                        % mod)
                        % mod;
            } else
                ans = (get(current, 0, 0) * get(vertex, index + 1, 0)) % mod;
        } else {
            if (C[current] == 1) {
                ans = (get(current, 0, 0) * get(vertex, index + 1, 0)) % mod;
                ans = (ans + (get(current, 0, 0) * get(vertex, index + 1, 1))
                        % mod)
                        % mod;
            } else {
                ans = (get(current, 0, 1) * get(vertex, index + 1, 0)) % mod;
                ans = (ans + (get(current, 0, 0) * get(vertex, index + 1, 1))
                        % mod)
                        % mod;
                ans = (ans + (get(current, 0, 1) * get(vertex, index + 1, 1))
                        % mod)
                        % mod;
            }
        }
        // System.out.println(vertex + " " + index + " " + color + " " + ans);
        DP[color].put(temp, ans);
        return ans;
    }

    public static void main(String[] args) throws NumberFormatException,
            IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(in.readLine());
        P = new int[n];
        E = new ArrayList[n];
        C = new int[n];
        for (int i = 0; i < n; i++)
            E[i] = new ArrayList<Integer>();
        String[] S = in.readLine().split(" ");
        for (int i = 0; i < S.length; i++) {
            int x = i + 1;
            int y = Integer.parseInt(S[i]);
            E[x].add(y);
            E[y].add(x);
        }
        S = in.readLine().split(" ");
        for (int i = 0; i < n; i++)
            C[i] = Integer.parseInt(S[i]);
        DP = new HashMap[2];
        for (int i = 0; i < 2; i++)
            DP[i] = new HashMap<Point, Long>();
        for (int i = 0; i < n; i++)
            if (E[i].size() == 1) {
                P[i] = -1;
                System.out.println(get(i, 0, 1 - C[i]));
                System.exit(0);
            }
    }
}
