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 
#dfs and similar-----graphs------trees------*1300 
# class Node(object):
#     def __init__(self, name):
#         self.name=name
    
#     def __str__(self):
#         return self.name
import sys
sys.setrecursionlimit(10000)
class Edge(object):
    def __init__(self, src, dest):
        self.src=src
        self.dest=dest
    
    def getSource(self):
        return self.src
    
    def getDestination(self):
        return self.dest
    
    def __str__(self):
        return str(self.src)+'->'+str(self.dest)

class Graph(object):
    def __init__(self):
        self.edges=dict()
    
    def addNode(self, node):
        if node in self.edges:
            return ValueError('Duplicate node')
        else:
            self.edges[node]=[]
        
    def addEdge(self, edge):
        src=edge.getSource()
        dest=edge.getDestination()
        if src not in self.edges :
            return ValueError('Source node absent')
        if dest in self.edges[src]: return #duplicate edge
        self.edges[src].append(dest)
        #self.edges[dest].append(src)

    def childrenOf(self, node):
        return self.edges[node]

    def hasNode(self, node):
        return node in self.edges

    def __str__(self):
        result = ''
        for src in self.edges:
            for dest in self.edges[src]:
                result = result + str(src) + '->' + str(dest) + '\n'
                        
        return result[:-1] #omit final newline

n=int(input())
graph= Graph()
#rootNodes=[]
graph.addNode(-1)

for i in range(1,n+1):
    if i not in graph.edges:    graph.addNode(i)

    parent = int(input())
    if parent not in graph.edges:    graph.addNode(parent)
        
    graph.addEdge(Edge(parent, i))

def findHeight(graph, rootNode):
    if len(graph.edges[rootNode])==0: return 1
    else:
        maxSubtreeHeight=0
        for child in graph.edges[rootNode] :
            h=1+findHeight(graph, child)
            maxSubtreeHeight=max(maxSubtreeHeight, h)

        return maxSubtreeHeight

print(findHeight(graph, -1)-1)