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>
#pragma GCC optimize("O3")
#pragma GCC target("avx2")
using namespace std;
const long long SIZE = 1e5 + 10, lg = 30;
long long n, l, s, cnt = 0, up[SIZE][lg], sz[SIZE][lg], ans = 0, pw[lg];
vector<long long> vec;
vector<vector<long long>> gr;
bool used[SIZE];
long long am[SIZE];
void dfs(int v) {
  used[v] = true;
  for (int i = 1; i < lg; i++) {
    up[v][i] = up[up[v][i - 1]][i - 1];
    sz[v][i] = sz[v][i - 1] + sz[up[v][i - 1]][i - 1];
  }
  for (auto to : gr[v]) {
    if (!used[to]) {
      up[to][0] = v;
      sz[to][0] = vec[v];
      dfs(to);
    }
  }
}
pair<long long, long long> find_ans(int v) {
  used[v] = true;
  vector<pair<long long, long long>> vc;
  for (auto to : gr[v]) {
    if (!used[to]) {
      pair<long long, long long> q = find_ans(to);
      if (q.second < l && q.first + vec[v] <= s) {
        q.second++;
        q.first += vec[v];
        vc.push_back(q);
      }
    }
  }
  if (vc.size() == 0) {
    ans++;
    if (s < vec[v]) {
      cout << "-1";
      exit(0);
    }
    return {vec[v], 1};
  } else {
    long long mx = -1;
    pair<long long, long long> cur = {-1, -1};
    for (int j = 0; j < vc.size(); j++) {
      long long gt = vc[j].first, curS = 0, u = v;
      for (int i = lg - 1; i >= 0; i--) {
        if (curS + (pw[i]) + vc[j].second <= l && gt + sz[u][i] <= s) {
          curS += pw[i];
          gt += sz[u][i];
          u = up[u][i];
        }
      }
      if (curS >= mx) {
        cur = vc[j];
        mx = curS;
      }
    }
    return cur;
  }
}
int main() {
  cin.tie(0);
  cout.tie(0);
  ios_base::sync_with_stdio(0);
  ;
  cin >> n >> l >> s;
  pw[0] = 1;
  gr.resize(n);
  vec.resize(n);
  for (int i = 1; i < lg; i++) pw[i] = pw[i - 1] * 2;
  for (int i = 0; i < n; i++) cin >> vec[i];
  for (int i = 1; i < n; i++) {
    long long u, v;
    cin >> u;
    u--;
    gr[u].push_back(i);
  }
  dfs(0);
  for (int i = 0; i < n; i++) used[i] = 0;
  find_ans(0);
  cout << ans;
  return 0;
}
