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 Party
{
	public static void main(String[]args) throws Exception
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int n = Integer.parseInt(br.readLine());
		ArrayList<Node> graph = new ArrayList<Node>();
		for(int i=0; i<n; i++)
			graph.add(new Node(i+1)); 
		Stack<Node> dfs = new Stack<Node>(); 
		for(int i=0; i<n; i++)
		{
			Node dest = graph.get(i);
			int input = Integer.parseInt(br.readLine());
			if(input==-1) dfs.push(dest);
			else
			{
				Node source = graph.get(input-1);
				source.conns.add(dest);
			}
		}
		int answer = -1; 
		while(!dfs.isEmpty())
		{
			Node u = dfs.pop();
			//System.out.println(u.name);
			answer = Math.max(u.depth, answer);
			for(int i=0; i<u.conns.size(); i++)
			{
				Node v = u.conns.get(i);
				if(!v.vis)
				{
					v.vis = true;
					v.depth = u.depth+1; 
					dfs.push(v);
				}
			}
		}
		System.out.println(answer);
	}
}

class Node
{
	int name; 
	int depth; boolean vis; 
	ArrayList<Node> conns;
	public Node(int name)
	{
		depth = 1; 
		this.name=name; 
		vis = false;
		conns = new ArrayList<Node>(); 
	}
}