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 codeforcesnew;

import java.util.Scanner;
//Prob 115A

public class Party {

	int n;
	boolean graph[][];
	int[] visited;
	Scanner input;
	boolean op;
	
	public Party(){
		input = new Scanner(System.in);
		n = input.nextInt();
		graph = new boolean[n+1][n+1];
		visited = new int[n+1];
		int a =0;
		for(int i=1;i<=n;i++) {
			a = input.nextInt();
			if(a==-1)
			graph[i][i]=true;                // if a employee is uppermost node , we link it to itself
			else graph[i][a]=true;          
		}
		int x=0;
		int max=0;
		for(int i=1;i<=n;i++){
			dfs(i,0,0);
			op=false;
			max=Math.max(max,visited[i]);
		}
		System.out.println(max);
	}
	//This dfs operates in two modes
	//1.Totally unvisited mode
	//2.Totally visited or partially visited mode
	public int dfs(int vertex,int count,int parent){
		if(visited[vertex]!=0){
			op=true;                    //true indicates mode 2
			return visited[vertex];
		}
		int s=0;
		
		for(int i=1;i<=n;i++)
		{
			if(graph[vertex][i]==true)
			{
				if(vertex==i) {
					visited[vertex]=1;
					return count+1;
				}
				else {
					s=dfs(i,count+1,vertex);// This is mode 1 case:
					if(op==true)                   //when you come out of dfs , the parent node value is simply one + s
					{
				    visited[vertex]=s+1;          //also you return this newly formed visited value instead of the s value
					return visited[vertex];        // why? because we are still building up the links backwards , we are not at the max value
					}
					else {
						visited[vertex]=s-count;  //This is the mode 2:
			                                      //In this case, we developed the "s" by traversing to the uppermost superior, hence we 
						                          // return this value,since this is maximum, and we also set the values of the visited nodes
						                          // for future mode 2 ops
						return s;
					}
				}
			}
		}
	                 return s;                     // if a node is a uppermost node , then this return executes 
	}
	
	public static void main(String[] args){
		new Party();
	}
}
