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 U = unsigned int;
using LL = long long;
using ULL = unsigned long long;
using LD = long double;
using std::bitset;
using std::cerr;
using std::cin;
using std::cout;
using std::endl;
using std::make_pair;
using std::map;
using std::pair;
using std::priority_queue;
using std::queue;
using std::set;
using std::string;
using std::vector;
using pii = std::pair<int, int>;
using pll = std::pair<LL, LL>;
class MyTimer {
 public:
  void reset() {}
  void report() {}
} myTimer;
template <typename T1, typename T2>
inline bool chmin(T1 &a, const T2 &b) {
  return a > b ? a = b, true : false;
}
template <typename T1, typename T2>
inline bool chmax(T1 &a, const T2 &b) {
  return a < b ? a = b, true : false;
}
inline int readint() {
  int a = 0;
  char c = getchar(), p = 0;
  while (isspace(c)) c = getchar();
  if (c == '-') p = 1, c = getchar();
  while (isdigit(c)) a = a * 10 + c - '0', c = getchar();
  return p ? -a : a;
}
inline LL readLL() {
  LL a = 0;
  char c = getchar(), p = 0;
  while (isspace(c)) c = getchar();
  if (c == '-') p = 1, c = getchar();
  while (isdigit(c)) a = a * 10 + c - '0', c = getchar();
  return p ? -a : a;
}
const int maxN = 100000 + 233;
const int INF = 0x3f3f3f3f;
int n, p[maxN], nlim, dep[maxN];
LL w[maxN], wlim;
int f[maxN], sum[maxN];
struct Node {
  int ans;
  LL weight;
  int node;
  Node(int ans, LL w, int node) : ans(ans), weight(w), node(node) {}
  bool operator<(const Node &rhs) const {
    return ans != rhs.ans         ? ans > rhs.ans
           : weight != rhs.weight ? weight < rhs.weight
                                  : node < rhs.node;
  }
};
void merge(priority_queue<Node> &Q, int &dans, LL &dweight,
           priority_queue<Node> &P, int &pans, LL &pweight) {
  if (Q.size() < P.size()) {
    std::swap(Q, P);
    std::swap(dans, pans);
    std::swap(dweight, pweight);
  }
  while (!P.empty()) {
    Node x = P.top();
    P.pop();
    Q.push(Node(x.ans + pans - dans, x.weight + pweight - dweight, x.node));
  }
}
priority_queue<Node> pq[maxN];
int dans[maxN];
LL dweight[maxN];
void solve() {
  memset(sum, 0, sizeof(sum));
  memset(f, INF, sizeof(f));
  memset(dans, 0, sizeof(dans));
  memset(dweight, 0, sizeof(dweight));
  for (int u = 1; u <= n; ++u) pq[u].push(Node(1, w[u], u));
  for (int u = n; u >= 1; --u) {
    priority_queue<Node> &Q = pq[u];
    while (1) {
      Node x = Q.top();
      if (dep[x.node] - dep[u] + 1 > nlim || x.weight + dweight[u] > wlim) {
        Q.pop();
        continue;
      }
      f[u] = x.ans + dans[u];
      break;
    }
    if (u == 1) break;
    dweight[u] += w[p[u]];
    dans[u] += sum[p[u]];
    dans[p[u]] += f[u];
    sum[p[u]] += f[u];
    merge(pq[p[u]], dans[p[u]], dweight[p[u]], pq[u], dans[u], dweight[u]);
  }
}
int main() {
  scanf("%d%d%lld", &n, &nlim, &wlim);
  for (int i = 1; i <= n; ++i) scanf("%lld", &w[i]);
  for (int i = 2; i <= n; ++i) scanf("%d", &p[i]);
  for (int i = 1; i <= n; ++i)
    if (w[i] > wlim) {
      cout << -1 << endl;
      return 0;
    }
  dep[1] = 1;
  for (int i = 2; i <= n; ++i) dep[i] = dep[p[i]] + 1;
  solve();
  cout << f[1] << endl;
  return 0;
}
