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 java.util.*;
import java.io.*;



public class bst
{
 
    
    /********* SOLUTION STARTS HERE ************/
 
    static int ff[];
    private static void solve(FastScanner s1, PrintWriter out){
        int t=s1.nextInt();
        int a[] = new int[t];
        int se[] = new int[t];
        
        //int y[] = new int[t];
        for(int i=0;i<t;++i){
            a[i] = s1.nextInt();
            se[i] = 0;
            //f[i] = false;
            //y[i] = 0;
        }
        for (int i=0;i<t;++i){
            //System.out.println(a[i]);
            depth(i,a,se);
        }
        int res = 0;
        for (int i=0;i<t;++i){
            if (res < se[i]){
                res = se[i];
            }
        }
        System.out.println(res);
    }
    static void depth(int i,int a[],int se[]){
        if (se[i] > 0){
            return ;
        }
        se[i] = 1;
        if (a[i] > 0){
            depth(a[i]-1,a,se);
            se[i] += se[a[i]-1];
        }
    }

    /********** TEMPLATE STARTS HERE ***********/
 
    public static void main(String []args) throws IOException {
    FastScanner in  = new FastScanner(System.in);
    PrintWriter out = 
        new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)), false); 
    solve(in, out);
    in.close();
    out.close();
    }    
 
    static class FastScanner{
    BufferedReader reader;
    StringTokenizer st;
    FastScanner(InputStream stream){reader=new BufferedReader(new InputStreamReader(stream));st=null;}  
    String next()
        {while(st == null || !st.hasMoreTokens()){try{String line = reader.readLine();if(line == null){return null;}            
         st = new StringTokenizer(line);}catch (Exception e){throw new RuntimeException();}}return st.nextToken();}
    String nextLine()  {String s=null;try{s=reader.readLine();}catch(IOException e){e.printStackTrace();}return s;}             
    int    nextInt()   {return Integer.parseInt(next());}
    long   nextLong()  {return Long.parseLong(next());}     
    double nextDouble(){return Double.parseDouble(next());}
    char   nextChar()  {return next().charAt(0);}
    int[]  nextIntArray(int n)         {int[] arr= new int[n];   int i=0;while(i<n){arr[i++]=nextInt();}  return arr;}
    long[] nextLongArray(int n)        {long[]arr= new long[n];  int i=0;while(i<n){arr[i++]=nextLong();} return arr;}  
    int[]  nextIntArrayOneBased(int n) {int[] arr= new int[n+1]; int i=1;while(i<=n){arr[i++]=nextInt();} return arr;}          
    long[] nextLongArrayOneBased(int n){long[]arr= new long[n+1];int i=1;while(i<=n){arr[i++]=nextLong();}return arr;}          
    void   close(){try{reader.close();}catch(IOException e){e.printStackTrace();}}              
    }
 
    /*********** TEMPLATE ENDS HERE *************/
}