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;
inline long long read() {
  long long x = 0, f = 1;
  char ch = getchar();
  for (; !isdigit(ch); ch = getchar())
    if (ch == '-') f = -f;
  for (; isdigit(ch); ch = getchar()) x = 10 * x + ch - '0';
  return x * f;
}
const int maxn = 100010;
int n, l;
long long s;
int anc[maxn][27], fa[maxn], depth[maxn], vis[maxn];
long long val[maxn], dis[maxn];
int len[maxn], f[maxn], g[maxn];
vector<int> G[maxn];
inline void predfs(int x, int ff) {
  dis[x] = dis[ff] + val[x];
  depth[x] = depth[ff] + 1;
  anc[x][0] = ff;
  for (int i = 1; i <= 20; i++) anc[x][i] = anc[anc[x][i - 1]][i - 1];
  for (auto to : G[x]) predfs(to, x);
  fa[x] = ff;
}
inline void dpdfs(int x) {
  f[x] = -1;
  g[x] = 0;
  int flag = 0;
  for (auto to : G[x]) {
    flag = 1;
    dpdfs(to);
    g[x] += g[to];
    f[x] = max(f[x], f[to] - 1);
  }
  if (!flag) {
    f[x] = len[x] - 1;
    g[x] = 1;
    return;
  }
  if (f[x] == -1) {
    f[x] = len[x] - 1;
    g[x]++;
  }
}
int main() {
  n = read();
  l = read();
  s = read();
  if (!l) {
    puts("-1");
    return 0;
  }
  for (int i = 1; i <= n; i++) {
    val[i] = read();
    if (val[i] > s) {
      puts("-1");
      return 0;
    }
  }
  for (int i = 2; i <= n; i++) {
    int fi = read();
    G[fi].push_back(i);
  }
  predfs(1, 0);
  for (int i = 1; i <= n; i++) {
    int xx = i;
    for (int j = 20; j >= 0; j--)
      if (anc[xx][j] != 0 && dis[i] - dis[fa[anc[xx][j]]] <= s &&
          depth[i] - depth[fa[anc[xx][j]]] <= l)
        xx = anc[xx][j];
    len[i] = depth[i] - depth[xx] + 1;
  }
  dpdfs(1);
  printf("%d\n", g[1]);
}
