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 MAX = 1e5 + 111;
const int LOG = 20;
int n, L;
long long S;
long long w[MAX];
int p[MAX], deg[MAX], l[MAX];
int up[MAX][LOG], dd[MAX];
long long sum[MAX][LOG];
vector<vector<int> > v;
queue<int> q;
bool cmp(int i, int j) { return w[i] < w[j]; }
void dfs(int ver, int d, int p = -1) {
  dd[ver] = d;
  for (auto to : v[ver]) {
    if (to != p) dfs(to, d + 1, ver);
  }
}
void init() {
  dfs(0, 0);
  for (int i = 1; i < n; ++i) {
    up[i][0] = p[i];
    sum[i][0] = w[p[i]];
  }
  for (int i = 1; i < LOG; ++i) {
    for (int j = 0; j < n; ++j) {
      up[j][i] = up[up[j][i - 1]][i - 1];
      sum[j][i] = sum[j][i - 1] + sum[up[j][i - 1]][i - 1];
    }
  }
}
int ss(int ver) {
  long long cur = w[ver];
  int curl = l[ver];
  for (int i = LOG - 1; i >= 0; --i) {
    if (cur + sum[ver][i] <= S && curl + (1 << i) <= L) {
      cur += sum[ver][i];
      curl += (1 << i);
      ver = up[ver][i];
    }
  }
  return dd[ver];
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cin >> n >> L >> S;
  for (int i = 0; i < n; ++i) {
    cin >> w[i];
    if (w[i] > S) {
      cout << -1;
      return 0;
    }
    l[i] = 1;
  }
  v.resize(n);
  for (int i = 1; i < n; ++i) {
    cin >> p[i];
    --p[i];
    v[p[i]].push_back(i);
    ++deg[p[i]];
  }
  init();
  for (int i = 0; i < n; ++i) {
    if (deg[i] == 0) {
      --deg[p[i]];
      if (deg[p[i]] == 0) q.push(p[i]);
    }
  }
  int ans = n;
  while (!q.empty()) {
    int ver = q.front();
    q.pop();
    int id = -1;
    int mn = dd[ver] + 1;
    for (auto to : v[ver]) {
      if (w[to] + w[ver] > S) continue;
      int d = ss(to);
      if (d < mn) {
        mn = d;
        id = to;
      }
    }
    if (id != -1) {
      --ans;
      w[ver] += w[id];
      l[ver] = l[id] + 1;
    }
    if (ver == 0) break;
    --deg[p[ver]];
    if (deg[p[ver]] == 0) {
      q.push(p[ver]);
    }
  }
  cout << ans;
  return 0;
}
