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 N = 100000 + 1;
const int LOGN = 20;
int n, L, w[N], depth[N], up[N], deg[N];
long long S, sum[N][LOGN], dp[N][LOGN];
bool vis[N];
vector<int> g[N];
void pre(int u, int p) {
  dp[u][0] = p;
  if (p != -1)
    sum[u][0] = w[p];
  else
    sum[u][0] = 2e18;
  for (auto v : g[u]) {
    depth[v] = depth[u] + 1;
    pre(v, u);
  }
}
int main() {
  cin >> n >> L >> S;
  for (int i = 1; i <= n; ++i) {
    scanf("%d", w + i);
    if (w[i] > S) {
      puts("-1");
      return 0;
    }
  }
  for (int p, i = 2; i <= n; ++i) {
    scanf("%d", &p);
    deg[p]++;
    g[p].push_back(i);
  }
  for (int i = 0; i < LOGN; ++i)
    for (int j = 1; j <= n; ++j) dp[j][i] = -1, sum[j][i] = 2e18;
  pre(1, -1);
  for (int i = 1; i < LOGN; ++i) {
    for (int j = 1; j <= n; ++j) {
      if (dp[j][i - 1] == -1) continue;
      dp[j][i] = dp[dp[j][i - 1]][i - 1];
      sum[j][i] = sum[j][i - 1] + sum[dp[j][i - 1]][i - 1];
    }
  }
  for (int u = 1; u <= n; ++u) {
    up[u] = max(0, depth[u] - (L - 1));
    int tmp = u;
    long long current_sum = w[u];
    for (int j = LOGN - 1; j >= 0; --j) {
      if (current_sum + sum[tmp][j] <= S) {
        current_sum += sum[tmp][j];
        tmp = dp[tmp][j];
      }
    }
    up[u] = max(up[u], depth[tmp]);
  }
  set<pair<int, int> > leaf;
  for (int i = 1; i <= n; ++i)
    if (deg[i] == 0) leaf.insert(make_pair(up[i], i));
  int ans = 0;
  while (leaf.size() > 0) {
    ans += leaf.size();
    vector<int> op;
    for (auto v : leaf) {
      int current = v.second;
      while (current != -1 && depth[current] >= v.first) {
        if (vis[current]) break;
        vis[current] = 1;
        current = dp[current][0];
        if (current != -1) deg[current]--;
      }
      if (current != -1) op.push_back(current);
    }
    leaf.clear();
    for (auto v : op) {
      if (deg[v] == 0 && !vis[v]) {
        leaf.insert(make_pair(up[v], v));
      }
    }
  }
  cout << ans << endl;
  return 0;
}
