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.*;

public class Solution {
	static Map<Integer, Node> nodes;

	public class Node {
		int id;
		int parent_id;
		List<Node> children;

		public Node(int id, int parent_id) {
			children = new ArrayList<>();
			this.id = id;
			this.parent_id = parent_id;
		}

		public void addChild(Node child) {
			children.add(child);
		}

		boolean areYouMyChild(Node node) {
			for (Node child : children) {
				if (node == child) {
					return true;
				} else {
					return child.areYouMyChild(node);
				}
			}

			return false;
		}

		boolean areYouMyParent(Node parent) {

			if (parent_id == parent.id)
				return true;
			else {
				Node myParent = nodes.get(parent_id);
				if (myParent == null || myParent.parent_id == -1)
					return false;

				return myParent.areYouMyParent(parent);
			}

		}

		int countMyChildren() {
			return countHelper(this,1,0);		
		}

		int countHelper(Node root, int sum, int result) {
			if (root == null)
				return 0;
			if (root.children.size()== 0)
				return sum;
			ArrayList<Integer> results = new ArrayList<>();
			
			for (Node child : root.children) {
				results.add(countHelper(child, 1+sum, result));
			}
			Collections.sort(results);
			Collections.reverse(results);
			

			return results.get(0) ;
		}
	}

	public static void main(String[] args) {
		Solution p = new Solution();
		Scanner s = new Scanner(System.in);
		int n = s.nextInt();
		int[] sup = new int[n + 1];
		for (int i = 1; i < sup.length; i++) {
			sup[i] = s.nextInt();
		}
		s.close();
		nodes = new TreeMap<>();
		for (int i = 1; i < sup.length; i++) {
			Node node = p.new Node(i, sup[i]);
			nodes.put(i, node);
		}

		for (int i = 1; i < sup.length; i++) {
			Node child = nodes.get(i);

			if (child.parent_id != -1) {
				Node parent = nodes.get(child.parent_id);
				parent.addChild(child);
			}
		}

		boolean visited[] = new boolean[n + 1];

		Node startNode = nodes.get(1);
		Stack<Node> stack = new Stack<>();
		stack.push(startNode);
		int count = 0;

		for (int i = 1; i < n + 1; i++) {
			if (nodes.get(i).parent_id == -1){
			int numberOfLevel = nodes.get(i).countMyChildren();
			if (count < numberOfLevel) {
				count = numberOfLevel;
			}}
		}

		// while (!stack.isEmpty()) {
		// Node sNode = stack.pop();
		//
		// // checking stop condition
		// if (visited[sNode.id])
		// continue;
		//
		// for (int i = 1; i < n + 1; i++) {
		// if (i != sNode.id) {
		// Node mNode = nodes.get(i);
		// // check for child parent
		// if (!visited[mNode.id]&&!sNode.areYouMyChild(mNode) &&
		// !sNode.areYouMyParent(mNode)) {
		// visited[mNode.id] = true;
		// } else {
		// stack.push(mNode);
		// }
		// }
		// }
		// count++;
		//
		// visited[sNode.id] = true;// mark as visited
		// }
		System.out.println(count);
	}

}
