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;
int _min(int x, int y) { return x < y ? x : y; }
int _max(int x, int y) { return x > y ? x : y; }
int read() {
  int s = 0, f = 1;
  char ch = getchar();
  while (ch < '0' || ch > '9') {
    if (ch == '-') f = -1;
    ch = getchar();
  }
  while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
  return s * f;
}
struct edge {
  int x, y, next;
} e[110000];
int len, last[110000];
long long S, s[20][110000];
int L, a[110000], top[110000], ans;
int fa[20][110000], dep[110000];
void ins(int x, int y) {
  e[++len].x = x, e[len].y = y;
  e[len].next = last[x];
  last[x] = len;
}
int jump(int x) {
  long long u = S - a[x];
  int now = L - 1;
  for (int i = 18; i >= 0; i--) {
    if (now >= (1 << i) && u >= s[i][x]) {
      now -= (1 << i);
      u -= s[i][x];
      x = fa[i][x];
    }
  }
  if (x)
    return x;
  else
    return 1;
}
void dfs(int x) {
  for (int i = 1; (1 << i) <= dep[x]; i++)
    fa[i][x] = fa[i - 1][fa[i - 1][x]],
    s[i][x] = s[i - 1][x] + s[i - 1][fa[i - 1][x]];
  top[x] = jump(x);
  for (int k = last[x]; k; k = e[k].next) {
    int y = e[k].y;
    dep[y] = dep[x] + 1;
    s[0][y] = a[x];
    dfs(y);
  }
}
void getans(int x) {
  int gg = 0;
  for (int k = last[x]; k; k = e[k].next) {
    int y = e[k].y;
    getans(y);
    if (top[y] == y) continue;
    if (gg == 0)
      gg = top[y];
    else if (dep[gg] > dep[top[y]])
      gg = top[y];
  }
  if (gg == 0) gg = top[x], ans++;
  top[x] = gg;
}
int main() {
  int n = read();
  L = read();
  cin >> S;
  for (int i = 1; i <= n; i++) {
    a[i] = read();
    if (a[i] > S) {
      printf("-1\n");
      return 0;
    }
  }
  for (int i = 2; i <= n; i++) ins(fa[0][i] = read(), i);
  dep[1] = 1;
  dfs(1);
  getans(1);
  printf("%d\n", ans);
  return 0;
}
