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>
long long n, l, s;
std::vector<std::pair<int, int> > A;
std::vector<std::vector<int> > G;
std::vector<long long> w, pref_w, h, p, rank, parent, marked, highest;
int find_parent(int v) {
  if (parent[v] == v) return v;
  parent[v] = find_parent(parent[v]);
  return parent[v];
}
int merge(int a, int b) {
  int pa = find_parent(a), pb = find_parent(b);
  if (pa == pb) return pa;
  if (rank[pa] == rank[pb]) {
    rank[pa] += 1;
    parent[pb] = pa;
    return pa;
  }
  if (rank[pa] < rank[pb]) std::swap(pa, pb);
  parent[pb] = pa;
  return pa;
}
void dfs(int v, int parent) {
  for (int i = 0; i < G[v].size(); i++)
    if (G[v][i] != parent) {
      h[G[v][i]] = h[v] + 1;
      pref_w[G[v][i]] = pref_w[v] + w[G[v][i]];
      dfs(G[v][i], v);
    }
}
int main() {
  std::cin >> n >> l >> s;
  w.resize(n);
  pref_w.resize(n);
  h.resize(n);
  p.resize(n);
  rank.resize(n, 0);
  parent.resize(n, 0);
  marked.resize(n, 0);
  highest.resize(n, -1);
  G.resize(n, std::vector<int>());
  for (int i = 0; i < n; i++) {
    parent[i] = i;
    highest[i] = i;
  }
  for (int i = 0; i < n; i++) {
    std::cin >> w[i];
    if (w[i] > s) {
      std::cout << "-1\n";
      return 0;
    }
  }
  p[0] = -1;
  for (int i = 1; i < n; i++) {
    std::cin >> p[i];
    p[i]--;
    G[i].push_back(p[i]);
    G[p[i]].push_back(i);
  }
  h[0] = 0;
  pref_w[0] = w[0];
  dfs(0, -1);
  for (int i = 0; i < n; i++) A.push_back(std::make_pair(h[i], i));
  int result = 0;
  std::sort(A.begin(), A.end());
  std::reverse(A.begin(), A.end());
  for (int i = 0; i < n; i++) {
    if (!marked[A[i].second]) {
      result += 1;
      int v = A[i].second;
      marked[v] = 1;
      if (v == 0) break;
      int end = highest[find_parent(p[v])], group = merge(v, p[v]);
      highest[group] = end;
      while (end != -1) {
        if (h[v] - h[end] + 1 <= l && pref_w[v] - pref_w[end] + w[end] <= s) {
          marked[end] = 1;
          {
            if (p[end] == -1) break;
            int h_tmp = highest[find_parent(p[end])], tmp = merge(end, p[end]);
            highest[tmp] = h_tmp;
            end = h_tmp;
          }
        } else {
          break;
        }
      }
    }
  }
  std::cout << result << "\n";
  return 0;
}
