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.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.Iterator;
import java.util.PriorityQueue;



public class acm_practice {

	static long need [];
	static long has [];
	static int n;
	static int m;
	static int s;
	
	static bugs [] bu;
	static ArrayList<Integer> x[];
	public static void main(String[] args) throws IOException {
		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
        
//        StringTokenizer st = new StringTokenizer(bf.readLine(), " ");
 
        int n=Integer.parseInt(bf.readLine());
        x = new ArrayList[n+1];
        
			 for(int j=0;j<n+1;j++) {
				 x[j]=new ArrayList<>();
			 }
        for(int i =0;i<n;i++) {
            int k=Integer.parseInt(bf.readLine());
            if(k==-1) {continue;}
        	x[k].add(i+1);
        }
        for(int i=0;i<n+1;i++) {
        dfs(i,0);
        }
        System.out.println(m);
    }
	static void dfs(int u,int s) {
	    s++;
		for(int v:x[u]) {
	    	
	    		dfs(v,s);
	    	
	    }
		m=Math.max(m, s);
	} 
	static class pair implements Comparable<pair> {
		int cr;
		long pre;
		public pair(int cr,long pre) {
			this.cr=cr;
		    this.pre=pre;
		}
		public int compareTo(pair p)
		{
			if(pre!= p.pre)
				return pre > p.pre ? 1 : -1;
			return cr - p.cr;
		}
		
	}
	 static class bugs implements Comparable<bugs>{
		int com;
		int idx;
		public bugs(int com, int idx) {
			this.com=com;
		    this.idx=idx;
		}
		public int compareTo(bugs o) {
			return com - o.com;
		}
	}
	
//	static class Scanner 
//	{
//		StringTokenizer st;
//		BufferedReader br;
//
//		public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}
//
//		public String next() throws IOException 
//		{
//			while (st == null || !st.hasMoreTokens()) 
//				st = new StringTokenizer(br.readLine());
//			return st.nextToken();
//		}
//
//		public int nextInt() throws IOException {return Integer.parseInt(next());}
//
//		public long nextLong() throws IOException {return Long.parseLong(next());}
//
//		public String nextLine() throws IOException {return br.readLine();}
//
//		public boolean ready() throws IOException {return br.ready();}
//
//		public double nextDouble(String x) 
//		{
//
//			StringBuilder sb = new StringBuilder("0");
//			double res = 0, f = 1;
//			boolean dec = false, neg = false;
//			int start = 0;
//			if(x.charAt(0) == '-')
//			{
//				neg = true;
//				start++;
//			}
//			for(int i = start; i < x.length(); i++)
//				if(x.charAt(i) == '.')
//				{
//					res = Long.parseLong(sb.toString());
//					sb = new StringBuilder("0");
//					dec = true;
//				}
//				else
//				{
//					sb.append(x.charAt(i));
//					if(dec)
//						f *= 10;
//				}
//			res += Long.parseLong(sb.toString()) / f;
//			return res * (neg?-1:1);
//		}
//
//
//	}
}
