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 par[20][100005], n, L, sol;
vector<int> ms[100005];
long long ss[20][100005], w[100005], S;
const long long inf = 2e18;
int dfs(int x) {
  int ret = 0;
  for (vector<int>::iterator i = ms[x].begin(); i != ms[x].end(); ++i) {
    int o = *i;
    int t = dfs(o);
    ret = max(ret, t - 1);
  }
  if (!ret) {
    sol++;
    int br = 0, sad = x;
    long long sum = 0;
    for (int i = 18; i >= 0; --i) {
      if (br + (1 << i) <= L && sum + ss[i][sad] <= S) {
        sum += ss[i][sad];
        br += (1 << i);
        sad = par[i][sad];
      }
    }
    ret = br;
  }
  return ret;
}
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  cout.tie(0);
  cin >> n >> L >> S;
  bool p = 1;
  for (int i = 1; i <= n; ++i) {
    cin >> w[i];
    if (w[i] > S) {
      p = 0;
    }
    ss[0][i] = w[i];
  }
  for (int i = 2; i <= n; ++i) {
    cin >> par[0][i];
    ms[par[0][i]].push_back(i);
  }
  if (!p) {
    cout << -1 << endl;
    return 0;
  }
  ss[0][0] = inf;
  for (int i = 1; i <= 18; ++i) {
    for (int j = 1; j <= n; ++j) {
      par[i][j] = par[i - 1][par[i - 1][j]];
      ss[i][j] = min(ss[i - 1][j] + ss[i - 1][par[i - 1][j]], inf);
    }
  }
  dfs(1);
  cout << sol << endl;
  return 0;
}
