A company has n employees numbered from 1 to n. Each employee either has no immediate manager or exactly one immediate manager, who is another employee with a different number. An employee A is said to be the superior of another employee B if at least one of the following is true:

  * Employee A is the immediate manager of employee B
  * Employee B has an immediate manager employee C such that employee A is the superior of employee C. 



The company will not have a managerial cycle. That is, there will not exist an employee who is the superior of his/her own immediate manager.

Today the company is going to arrange a party. This involves dividing all n employees into several groups: every employee must belong to exactly one group. Furthermore, within any single group, there must not be two employees A and B such that A is the superior of B.

What is the minimum number of groups that must be formed?

Input

The first line contains integer n (1 ≤ n ≤ 2000) — the number of employees.

The next n lines contain the integers pi (1 ≤ pi ≤ n or pi = -1). Every pi denotes the immediate manager for the i-th employee. If pi is -1, that means that the i-th employee does not have an immediate manager. 

It is guaranteed, that no employee will be the immediate manager of him/herself (pi ≠ i). Also, there will be no managerial cycles.

Output

Print a single integer denoting the minimum number of groups that will be formed in the party.

Examples

Input

5
-1
1
2
1
-1


Output

3

Note

For the first example, three groups are sufficient, for example: 

  * Employee 1 
  * Employees 2 and 4 
  * Employees 3 and 5 
//package com.company;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int e = in.nextInt();
        int[] ms = new int[e+1];
        Graph g = new Graph(e+1);
        int[] root = new int[e];
        int j=0;
        for(int i=1; i<=e; i++){
            ms[i] = in.nextInt();
            if(ms[i] != -1){
                g.addEdge(g,ms[i],i);
            }else{
                root[j] = i;
                j++;
            }
        }
        int max = Integer.MIN_VALUE;
        for(int x : root){
            int ans = g.BFSDepth(x);
            max = Math.max(ans,max);
        }
        System.out.println(max);

    }

    static class Graph {
        int V;
        LinkedList<Integer> adjListArray[];

        Graph(int V) {
            this.V = V;
            adjListArray = new LinkedList[V];
            for (int i = 0; i < V; i++) {
                adjListArray[i] = new LinkedList<Integer>();
            }
        }

        void addEdge(Graph graph, int src, int dest) {
            graph.adjListArray[src].addFirst(dest);
        }

        int BFSDepth(int s) {
            int depth=1;
            boolean visited[] = new boolean[V];
            visited[0] = true;
            LinkedList<Integer> queue = new LinkedList<Integer>();
            visited[s] = true;
            queue.add(s);
            queue.add(-1);

            while (queue.size() != 0) {
                s = queue.poll();
                if(s != -1){
                    Iterator<Integer> i = adjListArray[s].listIterator();
                    while (i.hasNext()) {
                        int n = i.next();
                        if (!visited[n]) {
                            visited[n] = true;
                            queue.add(n);
                        }
                    }
                }else{
                    if(!queue.isEmpty()){
                        depth++;
                        queue.add(-1);
                    }
                }
            }
            return depth;
        }
    }
}

