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>
int anc[100005][20], depth[100005] = {0}, fa[100005], head[100005] = {0},
                     tail = 0, vis[100005] = {0};
int len[100005], dp[100005], ans[100005];
int n, l;
long long s;
long long depth2[100005] = {0};
long long val[100005];
struct edge {
  int v, next;
} edges[100005 * 2];
inline void add_edge(int u, int v) {
  edges[++tail].v = v;
  edges[tail].next = head[u];
  head[u] = tail;
}
int cmp(int a, int b) { return depth[a] > depth[b]; }
void dfs(int u, int f) {
  depth2[u] = depth2[f] + val[u];
  depth[u] = depth[f] + 1;
  anc[u][0] = f;
  for (int i = 1; (1 << i) <= depth[u]; i++) {
    anc[u][i] = anc[anc[u][i - 1]][i - 1];
  }
  for (int i = head[u]; i; i = edges[i].next) {
    if (edges[i].v != f) {
      dfs(edges[i].v, u);
    }
  }
  fa[u] = f;
}
int dfs2(int u) {
  dp[u] = -1;
  ans[u] = 0;
  int flag = 0;
  for (int i = head[u]; i; i = edges[i].next) {
    flag = 1;
    if (edges[i].v != fa[u]) {
      dfs2(edges[i].v);
      ans[u] += ans[edges[i].v];
      dp[u] = std::max(dp[u], dp[edges[i].v] - 1);
    }
  }
  if (flag == 0) {
    dp[u] = len[u] - 1;
    ans[u] = 1;
    return 0;
  }
  if (dp[u] == -1) {
    dp[u] = len[u] - 1;
    ans[u]++;
  }
  return 0;
}
int main() {
  std::cin >> n >> l >> s;
  if (l == 0) {
    printf("-1");
    return 0;
  }
  for (int i = 1; i <= n; ++i) {
    std::cin >> val[i];
    if (val[i] > s) {
      printf("-1");
      return 0;
    }
  }
  for (int i = 2; i <= n; ++i) {
    int u;
    scanf("%d", &u);
    add_edge(i, u);
    add_edge(u, i);
  }
  dfs(1, 0);
  for (int i = 1; i <= n; ++i) {
    int u = i;
    for (int j = 20; j >= 0; --j) {
      if (anc[u][j] != 0 && depth2[i] - depth2[fa[anc[u][j]]] <= s &&
          depth[i] - depth[fa[anc[u][j]]] <= l)
        u = anc[u][j];
    }
    len[i] = depth[i] - depth[u] + 1;
  }
  dfs2(1);
  printf("%d", ans[1]);
  return 0;
}
