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;
void err() { cout << "\033[39;0m" << endl; }
template <template <typename...> class T, typename t, typename... Args>
void err(T<t> a, Args... args) {
  for (auto x : a) cout << x << ' ';
  err(args...);
}
template <typename T, typename... Args>
void err(T a, Args... args) {
  cout << a << ' ';
  err(args...);
}
const int N = 1 << 17;
int n, l;
int w[N];
vector<int> G[N];
int dep[N], top[N];
long long dp[N], s;
int fa[N][18];
void dfs(int u, int p = 0) {
  dp[u] = dp[p] + w[u];
  fa[u][0] = p;
  dep[u] = dep[p] + 1;
  for (int i = 1; i < 18; i++) fa[u][i] = fa[fa[u][i - 1]][i - 1];
  int& x = top[u];
  x = u;
  int d = l - 1;
  for (int i = 17; ~i; i--) {
    if (!fa[x][i] || (1 << i) > d) continue;
    if (dp[u] - dp[fa[x][i]] + w[fa[x][i]] > s) continue;
    d -= 1 << i, x = fa[x][i];
  }
  for (auto& v : G[u]) dfs(v, u);
}
int son[N], ans;
void solve(int u) {
  int mx = 0;
  for (auto& v : G[u]) {
    solve(v);
    if (son[v] == v) continue;
    if (mx == 0 || dep[mx] > dep[son[v]]) mx = son[v];
  }
  if (!mx) mx = top[u], ++ans;
  son[u] = mx;
  ;
}
int main() {
  scanf("%d%d%lld", &n, &l, &s);
  for (int i = 1; i <= n; i++) {
    scanf("%d", w + i);
    if (w[i] > s) return puts("-1"), 0;
  }
  for (int i = 1, j; i < n; i++) {
    scanf("%d", &j);
    G[j].push_back(i + 1);
  }
  dfs(1);
  for (int i = 1; i <= n; i++)
    ;
  solve(1);
  printf("%d\n", ans);
}
