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

/**
 * Author :     AV
 * At   :       @Home
 * Date :       20.10.2
 * ver. :       1.0
 * link :       
 * file :       cf/      
 */

// public class I_AM_AV{
class I_AM_AV{
    static private I_AM_AV_Template sc=new I_AM_AV_Template();
    static private StringBuilder sb=new StringBuilder();

    public static int code(int[] a, int n){
        return 0;
    }

    public static void main(String[] args) {
        int T=1;
        // T=sc.nextInt();
        while(T-->0){
            int n=sc.nextInt();
            // String s = sc.nextInt();
            int[] a=sc.input(n);
            int max, tmp;
            max = tmp = 0;
            for(int i=0; i<n; i++){
                tmp = 1;
                int index=i;
                while( index >= 0 && a[index]!=-1){
                    index = a[index] - 1;
                    tmp++;
                }
                // System.out.println("index = "+i+" tmp = "+tmp);
                max=Math.max(max, tmp);
            }
            sb.append(max + "\n");
        }
        System.out.print(sb);
    }
}

class I_AM_AV_Template{
    static private BufferedReader br;
    static private StringTokenizer st; 
    static public final int MOD=1000000007; //10^9+7

    I_AM_AV_Template(){
        br=new BufferedReader(new InputStreamReader(System.in));
    }  
    I_AM_AV_Template(String input)throws FileNotFoundException{
        System.setOut(new PrintStream(input));
    }
    I_AM_AV_Template(String input, String output)throws FileNotFoundException{
        System.setIn(new FileInputStream(input));
        System.setOut(new PrintStream(output));
    }
    /**
     * Use StringBuilder for output
     */
    String next() { 
        while (st == null || !st.hasMoreElements()) { 
            try{ 
                st = new StringTokenizer(br.readLine()); 
            } 
            catch (IOException e) { 
                e.printStackTrace(); 
            } 
        } 
        return st.nextToken(); 
    } 
    int nextInt() { return Integer.parseInt(next()); } 
    long nextLong() { return Long.parseLong(next()); } 
    double nextDouble() {  return Double.parseDouble(next()); } 
    String nextLine() { 
        String str = ""; 
        try{ 
            str = br.readLine(); 
        } 
        catch (IOException e) { 
            e.printStackTrace(); 
        } 
        return str; 
    }
    public int[] input(int n){
        int[] a=new int[n];
        for(int i=0;i<n;i++)
            a[i]=this.nextInt();
        return a;
    }
    public int sum(int[] a, int start, int end){
        return Arrays.stream(a, start, end).sum();
    }
    public <E>void display(E[] a, int start, int end){
        for (;start<end; start++) {
            System.out.print(a[start]+" ");
        }
        System.out.println();
    }
    public void displayMatrix(int[][] a){
        for(int[] x: a)
            System.out.println(Arrays.toString(x));
    }

    public int max(int[] arr){ return Arrays.stream(arr).max().getAsInt(); }
    public int min(int[] arr){ return Arrays.stream(arr).min().getAsInt(); }

    public <E> E max(E[] a, int n){
        E max=a[0];
        return max;
    }
    public boolean isPrime(int number){
        if(number <= 2)
            return number == 2;
        else
            return  (number % 2) != 0
                    &&
                IntStream.rangeClosed(3, (int) Math.sqrt(number))
                    .filter(n -> n % 2 != 0)
                    .noneMatch(n -> (number % n == 0));
        }
}

