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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.StringTokenizer;

public class Party {

    public static void main(String[] args) {
        MyScanner scanner = new MyScanner();

        try {
            int n = scanner.nextInt();
            Graph g = new Graph(n);
            List<Integer> l = new ArrayList<Integer>();
            for (int i=1 ; i<=n ; i++){
                int m = scanner.nextInt();
                if (m!=-1){
                    g.addEdge(m, i);
                    g.addEdge(i, m);
                } else{
                    l.add(i);
                }
            }

            for (Integer i : l){
                g.dfsVisit(g.nodes.get(i-1), 1);
            }

            System.out.println(g.maxHeight);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    static class MyScanner {

        BufferedReader br;
        StringTokenizer st;

        public MyScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        public String next() throws IOException {
            if (st == null || !st.hasMoreTokens()) {
                String line = br.readLine();
                st = new StringTokenizer(line);
            }
            return st.nextToken();
        }

        public int nextInt() throws IOException {
            String next = next();
            next.length();
            return Integer.parseInt(next);
        }
    }
}
class Graph{
    class Vertex{
        int n;
        int color;
        List<Integer> neighbour;

        public Vertex(int n){
            this.n = n;
            this.color = 0;
            neighbour = new ArrayList<Integer>();
        }
    }

    List<Vertex> nodes;

    public Graph(int n){
        nodes = new ArrayList<Vertex>();
        for (int i=1 ; i<=n ; i++){
            nodes.add(new Vertex(i));
        }
    }

    void addEdge(int a, int b){
        nodes.get(a-1).neighbour.add(b-1);
    }

    int maxHeight = 0;

    public void dfs(){
        for (Vertex v : nodes){
            if (v.color==0){
                dfsVisit(v, 1);
            }
        }
    }

    public void dfsVisit(Vertex vertex, int h){
        vertex.color = 1;
        for (Integer i : vertex.neighbour){
            Vertex vertex1 = nodes.get(i);
            if (vertex1.color == 0) dfsVisit(vertex1, h+1);
        }
        maxHeight = Math.max(maxHeight, h);
    }
}
