human
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 

=====
Write me a Python program to print a single integer denoting the minimum number of groups that will be formed in the party?
assistant
#Here is Python program to print a single integer denoting the minimum number of groups that will be formed in the party.

from collections import defaultdict as dc
class Graph:
        def __init__(self):
                self.color=dc(int)
                #self.visited=dc(int)
                #self.tout=dc(int)
                self.parent=dc(int)
                self.adjlist=dc(list)
                #self.cost=dc(int)
                self.d=dc(int)#count the depth of dfs including itself
                self.m=0#for maximumm depth
                self.a=[]
        def addedge(self,a,b,co):
                self.color[a]="white"
                self.color[b]="white"
                self.adjlist[a].append(b)
                #self.adjlist[b].append(a)#for directed remove this
                #self.cost[b]=co
        def printlist(self):
                #print(self.adjlist,"list")
                #print(self.color,"color")
               # print(self.cost,"cost")
                #print(self.tin,self.tout,"time")
                #print("parent",self.parent)
                print(self.m)
        def bfs(self,i):
                self.color[i]="gray"
                self.d[i]=0
                (self.a).append(i)
                while(len(self.a)>0):
                        p=(self.a).pop(0)
                        for i in self.adjlist[p]:
                                if self.color[i]=="white":
                                        self.color[i]="gray"
                                        self.parent[p]=i
                                        self.d[i]=self.d[p]+1
                                        self.m=max(self.d[i],self.m)
                                        self.a.append(i)
                                        #print(i)
                        self.color[p]="black"

n=int(input())
g=Graph()
b=[]
for i in range(n):
        a=int(input())
        g.addedge(a,i+1,0)
        if a==-1:
                b.append(i+1)

g.bfs(-1)
g.printlist()