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 
"""class node:
	def __init__(self):
		self.neighbour=[]
		self.parent=-1

def findchild(adj,curr,parent):
	ans=1
	queue=[curr]
	while queue:
		s=queue.pop(0)
		for l in adj[s].neighbour:
			if(adj[s].parent==l):
				continue
			ans+=1	
			adj[l].parent=s
			queue.append(l)
	return ans

for mmm in range(int(input())):
	n,q=map(int,input().split(" "))

	adj=[node() for i in range(n)]
	for i in range(n-1):
		e,r=map(int,input().split(" "))
		adj[e-1].neighbour.append(r-1)
		adj[r-1].neighbour.append(e-1)

	for i in range(q):
		for j in range(n):
			adj[j].parent=-1
		e,r=map(int,input().split(" "))
		e-=1
		r-=1
		path=[r]
		if(e!=r):
			queue=[e]
			while queue:
				s=queue.pop(0)
				for l in adj[s].neighbour:
					if(adj[s].parent==l):
						continue
					adj[l].parent=s
					queue.append(l)
					if(l==r):
						queue=[]
						break
			while adj[r].parent!=-1:
				path.append(adj[r].parent)
				r=adj[r].parent
		ans=len(path)
		for j in range(n):
			adj[j].parent=-1
		if(len(path)!=1):
			for j in range(len(path)):
				choose=[]
				for m in adj[path[j]].neighbour:				
					if(m in path):
						continue
					else:
						adj[m].parent=path[j]
						temp=findchild(adj,m,path[j])
						choose.append(temp)
						ans+=temp
				for i1 in range(len(choose)):
					for i2 in range(i1+1,len(choose)):
						ans+=(choose[i1]*choose[i2])
		else:
			choose=[]
			for m in adj[path[0]].neighbour:				
				adj[m].parent=path[0]
				temp=findchild(adj,m,path[0])
				choose.append(temp)
				ans+=temp
			for i1 in range(len(choose)):
				for i2 in range(i1+1,len(choose)):
					ans+=(choose[i1]*choose[i2])
		print(ans)			
"""

n=int(input())
parent=[-1 for i in range(n)]
depth=[0 for i in range(n)]
for i in range(n):
	parent[i]=max(-1,int(input())-1)

depth=0
for q in range(n):
	curr=0
	i=q
	while parent[i]!=-1:
		curr+=1
		i=parent[i]
	depth=max(depth,curr)

print(depth+1)	