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 sys
import threading
from collections import defaultdict
n = int(input())
adj = defaultdict(list)
root = []
for i in range(1,n+1):
    val = int(input())
    if val == -1:
        root.append(i)
    else: 
        adj[val].append(i)
        adj[i].append(val)

def dfs(node,par):
    height = 0
    for i in range(len(adj[node])):
        if adj[node][i]!=par:
            height = max(height, dfs(adj[node][i],node))
    return 1+height

def main():
    ans= -(10**7+7)
    # print(root[0],root[1])
    # print(adj)
    for i in range(len(root)):
        h = dfs(root[i],-1)
        ans =  max(ans,h)

    print(ans)

if __name__=="__main__":
    sys.setrecursionlimit(10**6)
    threading.stack_size(10**8)
    t = threading.Thread(target=main)
    t.start()
    t.join()