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 mod = 1e9 + 7;
struct Mint {
  long long v;
  explicit operator long long() const { return v; }
  Mint() { v = 0; }
  Mint(long long _v) {
    v = (-mod < _v && _v < mod) ? _v : _v % mod;
    if (v < 0) v += mod;
  }
  friend bool operator==(const Mint& a, const Mint& b) { return a.v == b.v; }
  friend bool operator!=(const Mint& a, const Mint& b) { return !(a == b); }
  friend bool operator<(const Mint& a, const Mint& b) { return a.v < b.v; }
  Mint& operator+=(const Mint& m) {
    if ((v += m.v) >= mod) v -= mod;
    return *this;
  }
  Mint& operator-=(const Mint& m) {
    if ((v -= m.v) < 0) v += mod;
    return *this;
  }
  Mint& operator*=(const Mint& m) {
    v = v * m.v % mod;
    return *this;
  }
  Mint& operator/=(const Mint& m) { return (*this) *= inv(m); }
  friend Mint pow(Mint a, long long p) {
    Mint ans = 1;
    assert(p >= 0);
    for (; p; p /= 2, a *= a)
      if (p & 1) ans *= a;
    return ans;
  }
  friend Mint inv(const Mint& a) {
    assert(a.v != 0);
    return pow(a, mod - 2);
  }
  Mint operator-() const { return Mint(-v); }
  Mint& operator++() { return *this += 1; }
  Mint& operator--() { return *this -= 1; }
  Mint operator++(int) {
    Mint temp;
    temp.v = v++;
    return temp;
  }
  Mint operator--(int) {
    Mint temp;
    temp.v = v--;
    return temp;
  }
  friend Mint operator+(Mint a, const Mint& b) { return a += b; }
  friend Mint operator-(Mint a, const Mint& b) { return a -= b; }
  friend Mint operator*(Mint a, const Mint& b) { return a *= b; }
  friend Mint operator/(Mint a, const Mint& b) { return a /= b; }
  friend ostream& operator<<(ostream& os, const Mint& m) {
    os << m.v;
    return os;
  }
  friend istream& operator>>(istream& is, Mint& m) {
    long long x;
    is >> x;
    m.v = x;
    return is;
  }
};
void solve() {
  int n;
  cin >> n;
  vector<vector<int>> adj(n);
  for (int i = 1; i < n; i++) {
    int p;
    cin >> p;
    adj[i].push_back(p);
    adj[p].push_back(i);
  }
  vector<int> col(n);
  for (int i = 0; i < n; i++) cin >> col[i];
  vector<array<Mint, 2>> dp(n);
  function<void(int, int)> dfs = [&](int node, int par) {
    dp[node][col[node]] = 1;
    for (int nxt : adj[node]) {
      if (nxt != par) {
        dfs(nxt, node);
        array<Mint, 2> ndp;
        ndp[0] += dp[node][0] * dp[nxt][0];
        ndp[1] += dp[node][1] * dp[nxt][0] + dp[node][0] * dp[nxt][1];
        ndp[0] += dp[node][0] * dp[nxt][1];
        ndp[1] += dp[node][1] * dp[nxt][1];
        dp[node] = ndp;
      }
    }
  };
  dfs(0, 0);
  cout << dp[0][1] << "\n";
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  ;
  cout << fixed << setprecision(20);
  ;
  int t = 1;
  for (int i = 1; i <= t; i++) {
    solve();
  }
}
