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 int C = 100001;
vector<vector<int> > tr(C);
int ij[C], a, b, n;
int s[C], is = 0, ip = 1, pre[C], apre[C], dep[C], son[C], par[21][C], ji[C],
          pw[22];
long long sum[21][C], f[C], S;
void proc_tree(int a, int n, vector<vector<int> > &tab, int ij[]) {
  s[0] = a, is = 1, pre[a] = 1, apre[1] = a, dep[a] = 1, ip = 2,
  sum[0][a] = f[a];
  int b;
  for (int z = 1; z <= n; z++) ji[z] = ij[z];
  while (is > 0) {
    a = s[is - 1];
    if (ji[a] > 0 && tab[a][ji[a] - 1] == par[0][a]) ji[a]--;
    if (ji[a] > 0)
      b = s[is] = tab[a][ji[a] - 1], pre[b] = ip, apre[ip] = b, par[0][b] = a,
      sum[0][b] = f[a], dep[b] = is + 1, ip++, is++, ji[a]--;
    else
      son[a]++, son[par[0][a]] += son[a], is--;
  }
}
void prep_lca(int f, int n) {
  par[0][1] = 1;
  for (int j = 1; j < f; j++) {
    for (int i = 1; i <= n; i++) {
      par[j][i] = par[j - 1][par[j - 1][i]];
      sum[j][i] = sum[j - 1][i] + sum[j - 1][par[j - 1][i]];
    }
  }
}
int anc(int a, int b) {
  if (pre[a] <= pre[b] && pre[a] + son[a] > pre[b]) return 1;
  return 0;
}
bool lypa = 0;
int wynn = 0, L, dp[C];
int lca(int a, int ff = 19) {
  int i, x = a, ver = 1;
  long long summ = f[a];
  for (i = ff; i >= 0; i--) {
    if (summ + sum[i][x] <= S && ver + pw[i] <= L)
      ver += pw[i], summ += sum[i][x], x = par[i][x];
  }
  return x;
}
int main() {
  int i, j, x, y;
  pw[0] = 1;
  for (i = 1; i < 22; i++) pw[i] = pw[i - 1] * 2;
  scanf("%d %d %lld", &n, &L, &S);
  for (i = 1; i <= n; i++) scanf("%lld", &f[i]);
  for (int z = 2; z <= n; z++)
    scanf("%d", &a), tr[z].push_back(a), tr[a].push_back(z), ij[a]++, ij[z]++;
  proc_tree(1, n, tr, ij);
  prep_lca(20, n);
  for (i = n; i > 0; i--) {
    x = apre[i];
    if (dp[x] == 0) {
      wynn++;
      if (S < f[x]) lypa = 1;
      y = lca(x), dp[x]++;
      if (y > 1) dp[par[0][y]]--;
    }
    dp[par[0][x]] += dp[x];
  }
  if (lypa == 1)
    printf("%d\n", -1);
  else
    printf("%d\n", wynn);
  return 0;
}
