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.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;

public class C {

    static final int MOD = (int) 1e9 + 7;
    static ArrayList<Integer>[] adjList;
    static int[][] memo;
    static int[] black, blackCount;

    static int mult(long...x) {
        long res = 1;
        for(long y: x)
            res = res * y % MOD;
     return (int) res;
    }

    static int dp(int u, int cut) {
        if(memo[cut][u] != -1)
            return memo[cut][u];
        int all = 1, allExceptOne = 0;
        for(int v: adjList[u])
            if(blackCount[v] > 0) {

                int v1 = dp(v, 1), v0 = dp(v, 0);
                allExceptOne = mult(allExceptOne, v1);
                allExceptOne = (allExceptOne + mult(all, v0)) % MOD;
                all = mult(all, v1);
            }
        int ret;
        if(blackCount[u] - black[u] == 0)
            ret = 1;
        else if(black[u] == 1)
            ret = all;
        else {
            ret = allExceptOne;
            if(cut == 1)
                ret = (ret + all) % MOD;
        }
        return memo[cut][u] = ret;
    }

    public static void main(String[] args) throws IOException {

        Scanner sc = new Scanner(System.in);
        PrintWriter out = new PrintWriter(System.out);

        int n = sc.nextInt();
        adjList = new ArrayList[n];
        for(int i = 0; i < n; ++i)
            adjList[i] = new ArrayList<>();
        for(int i = 1; i < n; ++i)
            adjList[sc.nextInt()].add(i);

        memo = new int[2][n];
        for(int[] x: memo)
            Arrays.fill(x, -1);

        black = new int[n];
        blackCount = new int[n];
        for(int i = 0; i < n; ++i)
            black[i] = sc.nextInt();
        for(int i = n - 1; i >= 0; --i) {
            blackCount[i] = black[i];
            for(int v: adjList[i])
                blackCount[i] += blackCount[v];
        }
        out.println(dp(0, 0));
        out.close();
    }

    static class Scanner
    {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}

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

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

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

        public String nextLine() throws IOException {return br.readLine();}

        public boolean ready() throws IOException {return br.ready();}


    }
}