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.
import java.util.*;
import java.io.*;
/*
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
Integer.parseInt(st.nextToken());
Long.parseLong(st.nextToken());
Scanner sc = new Scanner(System.in);


*/

public class Waw{
    
    static HashMap<Integer,Node> luckup = new HashMap<Integer,Node>();
    
    public static class Info{
        int paths;
        long value;
        public Info(int p,long v){
            paths = p;
            value = v;
        }
    }
    
    public static class Node{
        int id;
        long w;
        int parent;
        int nbf;
        int fils_termine;
        int paths;
        LinkedList<Info> values = new LinkedList<Info>();
        public Node(int id,long w){
            this.id = id;
            this.w = w;
            nbf = 0;
            fils_termine = 0;
            paths = 0;
        }
    }
    
    public static Node getNode(int id){
        return luckup.get(id);
    }
    
    public static int bfs(int n,int l,long s){
        
        LinkedList<Integer> nextToVisit = new LinkedList<Integer>();
        Node node;
        for(int i=1;i<=n;i++){
            node = getNode(i);
            if(node.w>s) return -1;
            if(node.nbf==0){
                node.values.add(new Info(1,node.w));
                nextToVisit.add(i);
            }
        }
        
        Info i;
        Info ip;
        long wp;
        int rep = 0;
       
        while(!nextToVisit.isEmpty()){
            node = getNode(nextToVisit.poll());
            Iterator<Info> it = node.values.iterator();
            
            if(node.id==1){
                
                return (node.paths+1);
            }
            wp = getNode(node.parent).w;
            
            while(it.hasNext()){
                i = it.next();
                
                i.paths++;
                if(i.paths>l) continue;
                i.value += wp;
                if(i.value>s) continue;
                Iterator<Info> itp = getNode(node.parent).values.iterator();
                rep = 0;
                while(itp.hasNext()){
                    ip = itp.next();
                    rep = verifie(i,ip);
                    if(rep == 1) {
                        itp.remove();
                        continue;
                    }
                    if(rep == -1) break;
                    
                }
                if(rep == -1) continue;
                getNode(node.parent).values.add(i);
               
            }
            getNode(node.parent).paths++;
            getNode(node.parent).paths += node.paths;
            getNode(node.parent).nbf--;
            if(getNode(node.parent).nbf==0){
                nextToVisit.add(node.parent);
                if(!getNode(node.parent).values.isEmpty()){
                    getNode(node.parent).paths--;
                }
                if(getNode(node.parent).values.isEmpty()){
                    getNode(node.parent).values.add(new Info(1,wp));
                    
                }
            }
           
            
        }
        return -1;
    }
    
    public static int verifie(Info i1,Info i2){
        // i2 hia dial linkedList dial parent
        
        // -1 i1 mamezianach
        // 1 i2 mamezianach
        // 0 bjoj zwane
        if(i1.value>=i2.value && i1.paths>=i2.paths) return -1;
        if(i1.paths<=i2.paths && i1.value<=i2.value) return 1;
        return 0;
    }
    
    public static void main(String[] args) throws Exception{
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int l = sc.nextInt();
        long s = sc.nextLong();
        long w = 0;
        for(int i=1;i<=n;i++){
            w = sc.nextLong();
            luckup.put(i,new Node(i,w));
        }
        getNode(1).parent = 0;
        int p = 0;
        for(int i=2;i<=n;i++){
            p = sc.nextInt();
            getNode(i).parent = p;
            getNode(p).nbf++;
        }
        
        int paths = bfs(n,l,s);
        System.out.println(paths);
        
    }
}