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
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
const int MAX = 1e9 + 5;
long long q[100005], prefix[100005], x, postfix[100005], dp[100005][2],
    col[100005], i, j, k, n, m;
vector<int> v[100005], tv[100005];
void dfs(int node, int root) {
  if (root != -1) v[root].push_back(node);
  for (__typeof(tv[node].begin()) it = tv[node].begin(); it != tv[node].end();
       it++)
    if ((*it) != root) dfs(*it, node);
}
long long fu(int x, int y) {
  if (!y) return 1;
  long long t = fu(x, y / 2);
  if (y & 1) return (((t * t) % 1000000007) * x) % 1000000007;
  return (t * t) % 1000000007;
}
int f(int x, bool t) {
  long long &r = dp[x][t];
  if (r != -1) return dp[x][t];
  r = 0;
  if (col[x]) {
    r = 1;
    for (__typeof(v[x].begin()) it = v[x].begin(); it != v[x].end(); it++)
      r = (r * f(*it, 1)) % 1000000007;
    return r;
  }
  long long s = 1;
  if (t) {
    for (__typeof(v[x].begin()) it = v[x].begin(); it != v[x].end(); it++)
      s = (s * f(*it, 1)) % 1000000007;
    r = s;
    s = 1;
  }
  for (__typeof(v[x].begin()) it = v[x].begin(); it != v[x].end(); it++)
    s = (s * f(*it, 1)) % 1000000007;
  for (__typeof(v[x].begin()) it = v[x].begin(); it != v[x].end(); it++) {
    r += ((fu(f(*it, 1), 1000000007 - 2) * s) % 1000000007) * f(*it, 0) %
         1000000007;
    r %= 1000000007;
  }
  return r;
}
int main() {
  memset(dp, -1, sizeof dp);
  scanf("%lld", &n);
  for (int i = 1; i <= n - 1; i++) {
    scanf("%lld", &x);
    tv[x + 1].push_back(i + 1);
    tv[i + 1].push_back(x + 1);
  }
  for (int i = 1; i <= n; i++) scanf("%lld", &col[i]);
  dfs(1, 0);
  cout << f(1, 0);
  return 0;
}
