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 MAXN = 100005;
const int MAXLOG = 20;
vector<pair<int, long long> > graph[MAXN];
int rt = 1;
int layer[MAXN];
pair<int, long long> pa[MAXN][MAXLOG];
long long weight[MAXN], sum[MAXN];
int n, l;
long long s;
int ans;
void init() {
  for (int i = 0; i < MAXN; i++) {
    graph[i].clear();
  }
  rt = 1;
}
pair<int, long long> goUp(int l, int step) {
  pair<int, long long> res = make_pair(l, 0);
  while (step) {
    int lowbit = 1;
    int tmp = step;
    while (tmp) {
      if (tmp % 2 == 1) {
        break;
      }
      tmp /= 2;
    }
    res.second += pa[l][lowbit].second;
    res.first = pa[l][lowbit].first;
    step -= lowbit;
    l = pa[l][lowbit].first;
  }
  return res;
}
void getLayer(int u = rt, int pre = -1, int l = 1) {
  layer[u] = l;
  sum[u] += weight[u];
  for (int i = 0; i < graph[u].size(); i++) {
    int v = graph[u][i].first;
    if (v == pre) {
      continue;
    }
    pa[v][1] = make_pair(u, graph[u][i].second);
    for (int i = 2; i < MAXLOG; i++) {
      if (pa[v][i - 1].first) {
        int papa = pa[v][i - 1].first;
        if (pa[papa][i - 1].first) {
          pa[v][i] = make_pair(pa[papa][i - 1].first,
                               pa[papa][i - 1].second + pa[v][i - 1].second);
        } else {
          for (int j = i; j < MAXLOG; j++) {
            pa[v][i] = make_pair(0, 0);
          }
          break;
        }
      } else {
        for (int j = i; j < MAXLOG; j++) {
          pa[v][i] = make_pair(0, 0);
        }
        break;
      }
    }
    sum[v] = sum[u];
    getLayer(v, u, l + 1);
  }
}
int dfs(int u = rt, int pre = -1) {
  bool update = false;
  int res = -1;
  for (int i = 0; i < graph[u].size(); i++) {
    int v = graph[u][i].first;
    if (v == pre) {
      continue;
    }
    update = true;
    int tmp = dfs(v, u);
    if (res == -1 || layer[tmp] < layer[res]) {
      res = tmp;
    }
  }
  if (!update || res == u) {
    int loc = u;
    int cnt = 1;
    long long csum = weight[u];
    for (int i = MAXLOG - 1; i >= 1; i--) {
      if (pa[loc][i].first == 0) {
        continue;
      }
      int cpa = pa[loc][i].first;
      if (csum + sum[loc] - sum[cpa] + weight[cpa] - weight[loc] <= s &&
          cnt + (1 << (i - 1)) <= l) {
        csum = csum + sum[loc] - sum[cpa] + weight[cpa] - weight[loc];
        cnt = cnt + (1 << (i - 1));
        loc = cpa;
      }
      if (i == 1) {
        if (pa[loc][i].first == 0) {
          continue;
        }
        cpa = pa[loc][i].first;
        if (csum + sum[loc] - sum[cpa] + weight[cpa] - weight[loc] <= s &&
            cnt + (1 << (i - 1)) <= l) {
          csum = csum + sum[loc] - sum[cpa] + weight[cpa] - weight[loc];
          cnt = cnt + (1 << (i - 1));
          loc = cpa;
        }
      }
    }
    ans++;
    return pa[loc][1].first;
  } else {
    return res;
  }
}
int main() {
  init();
  bool yes = true;
  scanf("%d%d%I64d", &n, &l, &s);
  for (int i = 1; i <= n; i++) {
    scanf("%I64d", &weight[i]);
    if (weight[i] > s) {
      yes = false;
    }
  }
  for (int i = 2; i <= n; i++) {
    int u;
    scanf("%d", &u);
    graph[u].push_back(make_pair(i, 1));
    graph[i].push_back(make_pair(u, 1));
  }
  if (!yes) {
    puts("-1");
  } else {
    getLayer();
    dfs();
    printf("%d\n", ans);
  }
  return 0;
}
