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 MAXN = 1e5 + 5;
const int LOG = 18;
int N, L;
long long T;
int w[MAXN];
vector<int> ch[MAXN];
int anc[MAXN][LOG];
int dep[MAXN];
long long sum[MAXN];
pair<int, long long> curr[MAXN];
struct cmp {
  bool operator()(const int &lhs, const int &rhs) const {
    if (dep[lhs] != dep[rhs]) return dep[lhs] > dep[rhs];
    return lhs > rhs;
  }
};
set<int, cmp> S;
void load() {
  scanf("%d%d%lld", &N, &L, &T);
  for (int i = 1; i <= N; i++) scanf("%d", w + i);
  for (int i = 2; i <= N; i++) {
    int x;
    scanf("%d", &x);
    ch[x].push_back(i);
    anc[i][0] = x;
  }
}
void dfs(int x, int d, long long s) {
  s += w[x];
  dep[x] = d;
  sum[x] = s;
  for (auto it : ch[x]) dfs(it, d + 1, s);
}
inline bool good(pair<int, long long> arg) {
  return arg.first <= L && arg.second <= T;
}
pair<int, long long> get(int x, int y) {
  return {dep[x] - dep[y] + 1, sum[x] - sum[y] + w[y]};
}
pair<int, long long> operator+(pair<int, long long> a, pair<int, long long> b) {
  return {a.first + b.first, a.second + b.second};
}
void operator+=(pair<int, long long> &a, pair<int, long long> b) { a = a + b; }
int reach(int x) {
  int y = x;
  for (int i = LOG - 1; i >= 0; i--)
    if (good(curr[x] + get(anc[x][0], anc[y][i]))) y = anc[y][i];
  return y;
}
long long solve() {
  for (int i = 1; i <= N; i++)
    if (w[i] > T) return -1;
  for (int j = 1; j < LOG; j++)
    for (int i = 1; i <= N; i++) anc[i][j] = anc[anc[i][j - 1]][j - 1];
  dfs(1, 0, 0);
  for (int i = 1; i <= N; i++) {
    curr[i] = {1, w[i]};
    S.insert(i);
  }
  int sol = 0;
  while (!S.empty()) {
    int x = *S.begin();
    if (x == 1) {
      sol++;
      break;
    }
    int dad = anc[x][0];
    int opt = -1, low = -1;
    for (auto it : ch[dad]) {
      int tmp = reach(it);
      if (opt == -1 || dep[tmp] < dep[low]) {
        opt = it;
        low = tmp;
      }
      S.erase(it);
    }
    sol += (int)ch[dad].size() - 1;
    if (low == opt)
      sol++;
    else
      curr[dad] += curr[opt];
  }
  return sol;
}
int main() {
  load();
  printf("%lld\n", solve());
  return 0;
}
