You are given a rooted tree on n vertices, its root is the vertex number 1. The i-th vertex contains a number w_i. Split it into the minimum possible number of vertical paths in such a way that each path contains no more than L vertices and the sum of integers w_i on each path does not exceed S. Each vertex should belong to exactly one path.

A vertical path is a sequence of vertices v_1, v_2, …, v_k where v_i (i ≥ 2) is the parent of v_{i - 1}.

Input

The first line contains three integers n, L, S (1 ≤ n ≤ 10^5, 1 ≤ L ≤ 10^5, 1 ≤ S ≤ 10^{18}) — the number of vertices, the maximum number of vertices in one path and the maximum sum in one path.

The second line contains n integers w_1, w_2, …, w_n (1 ≤ w_i ≤ 10^9) — the numbers in the vertices of the tree.

The third line contains n - 1 integers p_2, …, p_n (1 ≤ p_i < i), where p_i is the parent of the i-th vertex in the tree.

Output

Output one number — the minimum number of vertical paths. If it is impossible to split the tree, output -1.

Examples

Input

3 1 3
1 2 3
1 1


Output

3

Input

3 3 6
1 2 3
1 1


Output

2

Input

1 1 10000
10001


Output

-1

Note

In the first sample the tree is split into \{1\},\ \{2\},\ \{3\}.

In the second sample the tree is split into \{1,\ 2\},\ \{3\} or \{1,\ 3\},\ \{2\}.

In the third sample it is impossible to split the tree.
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const long double EPS = 1e-7;
long long n_log = 1, n, l, s, ans = 0;
vector<long long> w, pref_sum;
vector<vector<long long> > g, up;
vector<pair<long long, long long> > dp;
void dfs_init(long long v, long long p) {
  pref_sum[v] += w[v];
  up[0][v] = p;
  for (long long to : g[v]) {
    pref_sum[to] += pref_sum[v];
    dfs_init(to, v);
  }
}
long long get_res(long long v, pair<long long, long long> can_go) {
  if (can_go.first == 0 || can_go.second < w[v]) {
    return INF;
  }
  long long nv = v, len = 1, sum = 0, to;
  for (long long i = n_log; i >= 0; --i) {
    to = up[i][nv];
    if (len + (1 << i) <= can_go.first &&
        (sum + pref_sum[v] - pref_sum[to] + w[to]) <= can_go.second) {
      nv = to;
    }
  }
  return pref_sum[nv];
}
void dfs_dp(long long v) {
  long long best_to = -1, min_cnt_go = INF;
  for (long long to : g[v]) {
    dfs_dp(to);
    long long cnt_go = get_res(v, dp[to]);
    if (cnt_go < min_cnt_go) {
      min_cnt_go = min(min_cnt_go, cnt_go);
      best_to = to;
    }
  }
  if (best_to == -1 || dp[best_to].first == 0 || dp[best_to].second < w[v]) {
    dp[v] = {l - 1, s - w[v]};
    ++ans;
  } else {
    dp[v].first = dp[best_to].first - 1;
    dp[v].second = dp[best_to].second - w[v];
  }
}
signed main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  cin >> n >> l >> s;
  w.resize(n);
  for (long long& it : w) {
    cin >> it;
    if (it > s) {
      cout << "-1\n";
      return 0;
    }
  }
  g.resize(n);
  for (long long i = 0; i < n - 1; ++i) {
    long long p;
    cin >> p;
    --p;
    g[p].push_back(i + 1);
  }
  pref_sum.resize(n, 0);
  while ((1 << n_log) < n) ++n_log;
  up.resize(n_log + 1, vector<long long>(n, 0));
  dfs_init(0, 0);
  for (long long i = 1; i <= n_log; ++i) {
    for (long long j = 0; j < n; ++j) {
      up[i][j] = up[i - 1][up[i - 1][j]];
    }
  }
  dp.resize(n);
  dfs_dp(0);
  cout << ans << endl;
  return 0;
}
