There are N towns in Snuke Kingdom, conveniently numbered 1 through N. Town 1 is the capital.

Each town in the kingdom has a Teleporter, a facility that instantly transports a person to another place. The destination of the Teleporter of town i is town a_i (1≤a_i≤N). It is guaranteed that one can get to the capital from any town by using the Teleporters some number of times.

King Snuke loves the integer K. The selfish king wants to change the destination of the Teleporters so that the following holds:

* Starting from any town, one will be at the capital after using the Teleporters exactly K times in total.



Find the minimum number of the Teleporters whose destinations need to be changed in order to satisfy the king's desire.

Constraints

* 2≤N≤10^5
* 1≤a_i≤N
* One can get to the capital from any town by using the Teleporters some number of times.
* 1≤K≤10^9

Input

The input is given from Standard Input in the following format:


N K
a_1 a_2 ... a_N


Output

Print the minimum number of the Teleporters whose destinations need to be changed in order to satisfy King Snuke's desire.

Examples

Input

3 1
2 3 1


Output

2


Input

4 2
1 1 2 2


Output

0


Input

8 2
4 1 2 3 1 2 3 4


Output

3
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.io.InputStreamReader;
import java.io.Writer;
import java.io.BufferedReader;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Niyaz Nigmatullin
 */
public class Main {
    public static void main(String[] args) {
        new Thread(null, new Runnable() {
            @Override
            public void run() {
                InputStream inputStream = System.in;
                OutputStream outputStream = System.out;
                FastScannerTokenizer in = new FastScannerTokenizer(inputStream);
                FastPrinter out = new FastPrinter(outputStream);
                TaskD solver = new TaskD();
                solver.solve(1, in, out);
                out.close();

            }
        }, "", 1 << 27).start();
    }

    static class TaskD {
        static List<Integer>[] edges;
        static int[] kill;
        static int[] left;
        static int k;

        public void solve(int testNumber, FastScannerTokenizer in, FastPrinter out) {
            int n = in.nextInt();
            k = in.nextInt();
            int[] a = new int[n];
            for (int i = 0; i < n; i++) a[i] = in.nextInt() - 1;
            int ans = 0;
            if (a[0] != 0) {
                a[0] = 0;
                ans++;
            }
            edges = new List[n];
            for (int i = 0; i < n; i++) {
                edges[i] = new ArrayList<>();
            }
            for (int i = 1; i < n; i++) {
                edges[a[i]].add(i);
            }
            kill = new int[n];
            left = new int[n];
            dfs(0);
            out.println(kill[0] + ans);
        }

        static void dfs(int v) {
            kill[v] = 0;
            left[v] = 0;
            for (int it = 0; it < edges[v].size(); it++) {
                int to = edges[v].get(it);
                dfs(to);
                kill[v] += kill[to];
                if (left[to] == k - 1 && v != 0) {
                    kill[v]++;
                } else {
                    left[v] = Math.max(left[v], left[to] + 1);
                }
            }
        }

    }

    static class FastScannerTokenizer {
        BufferedReader br;
        StringTokenizer st;
        IOException happened;

        public FastScannerTokenizer(InputStream is) {
            br = new BufferedReader(new InputStreamReader(is));
        }

        public boolean hasNext() {
            while (st == null || !st.hasMoreTokens()) {
                String line;
                try {
                    line = br.readLine();
                } catch (IOException e) {
                    happened = e;
                    return false;
                }
                if (line == null) {
                    return false;
                }
                st = new StringTokenizer(line);
            }
            return true;
        }

//    public String next() {
//        if (!hasNext()) {
//            return null;
//        }
//        return st.nextToken();
//    }

        public String next() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    String line = br.readLine();
                    st = new StringTokenizer(line);
                } catch (IOException e) {
                    happened = e;
                    return null;
                }
            }
            return st.nextToken();
        }

        public String nextToken() {
            while (st == null || !st.hasMoreTokens()) {
                try {
                    String line = br.readLine();
                    if (line == null) {
                        return null;
                    }
                    st = new StringTokenizer(line);
                } catch (IOException e) {
                    happened = e;
                    return null;
                }
            }
            return st.nextToken();
        }

        public int indianNextInt() {
            String e = nextToken();
            if (e == null) {
                return 0;
            }
            return Integer.parseInt(e);

        }

        public int fastNextInt() {
            try {
                int c = br.read();
                while (c <= 32 && c >= 0) {
                    c = br.read();
                }
                if (c == -1) {
                    throw new NoSuchElementException();
                }
                int sgn = 1;
                if (c == '-') {
                    sgn = -1;
                    c = br.read();
                }
                if (c < '0' || c > '9') {
                    throw new NumberFormatException("digit expected " + (char) c
                            + " found");
                }
                int ret = 0;
                while (c >= '0' && c <= '9') {
                    ret = ret * 10 + c - '0';
                    c = br.read();
                }
                if (c > 32) {
                    throw new NumberFormatException("space character expected "
                            + (char) c + " found");
                }
                return ret * sgn;
            } catch (IOException e) {
                return Integer.MIN_VALUE;
            }
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public String nextLine() {
            try {
                if (st != null && st.hasMoreTokens()) {
                    StringBuilder ret = new StringBuilder();
                    while (st.hasMoreElements()) {
                        ret.append(st.nextElement());
                    }
                    return ret.toString();
                } else {
                    String line = br.readLine();
                    return line;
                }
            } catch (IOException e) {
                happened = e;
                return null;
            }
        }

        public void skipLine() {
            if (st == null || !st.hasMoreElements()) {
                try {
                    br.readLine();
                } catch (IOException e) {
                    happened = e;
                    return;
                }
            } else {
                st = null;
            }
        }

        public int readTimeHM(char delim) {
            String s = next();
            int pos = s.indexOf(delim);
            if (pos < 0) {
                throw new NumberFormatException("no delim found");
            }
            return Integer.parseInt(s.substring(0, pos)) * 60 + Integer.parseInt(s.substring(pos + 1));
        }

        public int readTimeHMS(char delim1, char delim2) {
            String s = next();
            int pos = s.indexOf(delim1);
            if (pos < 0) {
                throw new NumberFormatException("no delim found");
            }
            int pos2 = s.indexOf(delim2, pos + 1);
            if (pos2 < 0) {
                throw new NumberFormatException("no second delim found");
            }
            return Integer.parseInt(s.substring(0, pos)) * 3600 + Integer.parseInt(s.substring(pos + 1, pos2)) * 60
                    + Integer.parseInt(s.substring(pos2 + 1));
        }

        public int readTimeHMS(char delim) {
            return readTimeHMS(delim, delim);
        }
    }


    static class FastPrinter extends PrintWriter {
        public FastPrinter(OutputStream out) {
            super(out);
        }

        public FastPrinter(Writer out) {
            super(out);
        }

    }
}

