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 
n = int(input())
inp = []
for getInput in range(n):
    inp.append(int(input()) - 1)

#print("INNP IS", inp)
def recurse(currIndex):
    global l
    # if inp[currIndex] == -2:
    #     return
    # else:
    #     l.add(inp[currIndex])
    #     recurse(inp[currIndex])
    #
    i = currIndex
    while(True):
        if inp[i] == -2:
            return
        else:
            l.add(inp[i])
            i = inp[i]
#
# def recurse2(currIndex2):
#     global p
#     if inp[currIndex2] == -2:
#         p.add(currIndex2)
#         return
#     else:
#         p.add(inp[currIndex2])
#         recurse2(inp[currIndex2])

l = set()
m = 0
for i in range(n):
    l.clear()
    recurse(i)
    if len(l) > m:
        m=len(l)

print(m + 1)







# p = set()
#
# inp = [-2, -2, -2, -2, -2]
#
# bigList = []
# bigList.append([0])
#n = 5
#
# for index in range(1, n):
#     #print("\nINDEX IS ", index)
#     #print("BIGLIST IS ", bigList)
#     l.clear()
#     p.clear()
#     recurse2(index)
#     #print("p rn is", p)
#     canJoin = True
#     for party in bigList:
#         #print("current party ", party)
#         canJoin = True
#         for part in party:
#             l.clear()
#             recurse(part)
#             #print("l rn is", l)
#             if index in l:
#                 canJoin = False
#                 #print("not special")
#                 break
#
#             if part in p:
#                 canJoin = False
#                 #print("part is in p")
#                 break
#         if canJoin == True:
#             party.append(index)
#             #print("join existing party", party)
#             #print("and bigList is ", bigList)
#             break
#     if canJoin == False:
#         newParty = [index]
#         bigList.append(newParty)
#         #print("CANNOT")
#
# print(len(bigList))
# #print(bigList)
#
#
# # l=set()
# # inp = [-2, 0, 1, 0, -2]
# # recurse(4)
# #
# # #print(l)
