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.*;
import java.io.*;
 
public class Main {
 
	public static void main(String[] args) throws IOException, InterruptedException {
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		adjList=new ArrayList[n];
		for (int i = 0; i < n; i++) {
			adjList[i]=new ArrayList<>();
		}
		for (int i = 0; i < n; i++) {
			int m=sc.nextInt();
			if (m!=-1) {
				adjList[m-1].add(i);
			}
		}
		int max=0;
		for (int i = 0; i < n; i++) {
			c=1;
			visited=new boolean[n];
			bfs(i);
//			pw.println(c);
			max=Math.max(max,c);
		}
		pw.println(max);
//		pw.println(Arrays.toString(adjList));
	    pw.close();
	}
	
	static PrintWriter pw=new PrintWriter(System.out);
	static ArrayList<Integer>[] adjList;
	static boolean[] visited;
	static int c=1;
	static void dfs(int u){
		visited[u] = true;
		for(int v : adjList[u]){
			if(!visited[v]){
				c++;
				dfs(v);
			}
		}
	}
	static void bfs(int s){
		Queue<Integer> q = new LinkedList<>();
		q.add(s);
		visited[s] = true;
		while(!q.isEmpty()){
			boolean f=true;
			int m=q.size();
			for (int i = 0; i < m; i++) {
				int u=q.poll();
				for(int v : adjList[u]){
					f=false;
					if(!visited[v]){
						q.add(v);
						visited[v] = true;
					}
				}
			}
//			pw.println(q+" "+c);
			if(!f) c++;
		}
	}
	
	
	static class Scanner {
		StringTokenizer st;
		BufferedReader br;
 
		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}
 
		public boolean hasNext() {
			// TODO Auto-generated method stub
			return false;
		}
 
		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 double nextDouble() throws IOException {
			String x = next();
			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);
		}
 
		public boolean ready() throws IOException {
			return br.ready();
		}
 
	}

}