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.OutputStream;
import java.io.IOException;
import java.util.Arrays;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.InputStream;
import java.io.DataInputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author karan173
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastReader in = new FastReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }
}

class TaskA {
    int[] depth;
    int[] par;
    public void solve(int testNumber, FastReader in, PrintWriter out)
    {
        int n = in.nextInt();

        depth = new int[n+1];
        Arrays.fill(depth, -1);
        int maxDepth = -1;

        par = new int[n+1];
        for(int i = 1; i<=n; i++)
        {
            par[i] = in.nextInt();
            if(par[i] == -1)
                depth[i] = 0;
        }
        for(int i = 1; i<=n; i++)
        {
            depth[i] = dfs(i);
            maxDepth = Math.max(maxDepth, depth[i]);
          //  out.println(depth[i]);
        }
        out.println(maxDepth+1);

    }

    private int dfs(int i)
    {
        if(depth[i] == -1)
        {
              depth[i] = dfs(par[i]) +1;
        }
        return depth[i];
    }
}

class FastReader
{
    final private int BUFFER_SIZE = 1 << 17;

    private DataInputStream din;
    private byte[] buffer;
    private int bufferPointer, bytesRead;

    public FastReader(InputStream in) {
        din = new DataInputStream(in);
        buffer = new byte[BUFFER_SIZE];
        bufferPointer = bytesRead = 0;
    }
    public byte next()
    {
        try {
            return read();
        } catch (Exception e) {
            throw new InputMismatchException();
        }
    }

    public int nextInt() {
        int ret = 0;
        byte c = next();
        while (c <= ' ')
            c = next();
        boolean neg = c == '-';
        if (neg)
            c = next();
        do {
            ret = (ret << 3) + (ret << 1) + c - '0';
            c = next();
        } while (c > ' ');
        if (neg)
            return -ret;
        return ret;
    }

    private void fillBuffer() {
        try {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
        } catch (IOException e) {
            throw new InputMismatchException();
        }
        if (bytesRead == -1)
            buffer[0] = -1;
    }

    private byte read()  {
        if (bufferPointer == bytesRead)
            fillBuffer();
        return buffer[bufferPointer++];
    }
}
