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 
import java.util.ArrayList;
import java.util.Scanner;

public class Party {
    private static int depth = 1;
    private static int deepestdepth = 0;
    public static void main(String[] args) {
      Scanner scan = new Scanner(System.in);
      int N = scan.nextInt();
      int num = N;
      Graph g = new Graph(N + 1);
      int i = 0;
      while(N-- > 0){
          int manager = scan.nextInt();
          i++;
          if(manager == -1) continue;
          g.addEdge(i, manager);
      }
      // find deepest depth of the graph
      for ( i = 1; i <= num; i++)
          findDeepestDFS(g, i, depth);
      System.out.println(deepestdepth);
      scan.close();
    }

   private static void findDeepestDFS(Graph g, int i, int depth) {
        if( depth > deepestdepth ) 
            deepestdepth = depth;
        
        for (Vertex  ver : g.getVertex(i).getAdjacencyList())
            findDeepestDFS(g, ver.getVertex(), depth + 1);
    }

static class Graph{
        private int vertex;
        private ArrayList<Vertex> vertices = null;
       public Graph(int vertex){
           this.vertex = vertex;
           this.vertices = new ArrayList<>(vertex);
           vertices.add(0, null);
           for (int i = 1; i < vertex; ++i){
               vertices.add(i, new Vertex(i));
           } 
       }
       public void addEdge(int s, int v){
           this.vertices.get(s).addEdge(this.vertices.get(v));
       }
       public Vertex getVertex( int v){
           return this.vertices.get(v);
       }
       
       public String toString(){
           String result = "";
           for( int i = 1; i < vertex; i++){
               result += this.vertices.get(i).toString();
               result += "\n";
           }
           return result;
       }
    }
    static class Vertex{
        int  v = 0;
        private ArrayList<Vertex> adjacencyList = null;
        
        public ArrayList<Vertex> getAdjacencyList() {
            return adjacencyList;
        }
        
        public void setAdjacencyList(ArrayList<Vertex> adjacencyList) {
            this.adjacencyList = adjacencyList;
        }
        public Vertex(int v){
           this.v = v; 
           adjacencyList = new ArrayList<>();
        }
        public int getVertex (){
            return this.v;
        }
        public void addEdge(Vertex vertex){
            this.adjacencyList.add(vertex);
        }
        public String toString(){
            return this.v +" --- "+this.adjacencyList.toString();
        }
    }
}
