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.io.BufferedReader;
import java.io.File;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;
import java.util.StringTokenizer;


public class CF199A {
	public static void main(String[] args) throws Exception{
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		int[] array = new int[N];
		for(int a=0;a<N;a++)array[a]=sc.nextInt()-1;
		int ans = 0;
		for(int a=0;a<N;a++){
			ans=Math.max(ans,thing(array,a));
		}
		System.out.println(ans);
	}

	private static int thing(int[] array, int a) {
		if(array[a]==-2)return 1;
		return 1+thing(array,array[a]);
	}
	

}
class C implements Comparable<C>{
	int a,b;
	C(int aa, int bb){
		a=aa;
		b=bb;
	}
	@Override
	public int compareTo(C o) {
		
		return o.a-this.a;
	}
}
class FastScanner {
	BufferedReader br;
	StringTokenizer st;
	
	public FastScanner(InputStream in) throws Exception{
		br = new BufferedReader(new InputStreamReader(in));
		st = new StringTokenizer(br.readLine().trim());
	}
	public int numTokens() throws Exception {
		if(!st.hasMoreTokens()){
			st = new StringTokenizer(br.readLine().trim());
			return numTokens();
		}
		return st.countTokens();
	}
	public String next() throws Exception {
		if(!st.hasMoreTokens()){
			st = new StringTokenizer(br.readLine().trim());
			return next();
		}
		return st.nextToken();
	}
	public double nextDouble() throws Exception{
		return Double.parseDouble(next());
	}
	public float nextFloat() throws Exception{
		return Float.parseFloat(next());
	}
	public long nextLong() throws Exception{
		return Long.parseLong(next());
	}
	public int nextInt() throws Exception{
		return Integer.parseInt(next());
	}
	public String nextLine() throws Exception{
		return br.readLine().trim();
	}
}
class thing implements Comparable<thing>{
	int n;
	int pos;
	thing(int a, int b){
		this.n=a;
		this.pos=b;
	}
	@Override
	public int compareTo(thing o) {
		return this.n-o.n;
	}
}