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

public class BasicJava 
{
   public static void main(String[] args) 
   {
      Task Main = new Task();
      
      Main.solve();   
   }
   
   public static class Task
   {
      InputReader in = new InputReader(System.in);
      PrintWriter out = new PrintWriter(System.out);
      
      public int ans = 1;
      public ArrayList<Integer>[] g = (ArrayList<Integer>[])new ArrayList[2010];
      
      public int[] dp = new int[2010];
      
      public void dfs(int x, int dad)
      {
         ans = Math.max(ans, dp[x]);
         
         for (int i = 0; i < g[x].size(); i++)
            if (g[x].get(i).compareTo(dad) != 0) {
               dp[g[x].get(i)] = Math.max(dp[g[x].get(i)], dp[x] + 1); 
               dfs(g[x].get(i), x);
            }
      }
      
      public void solve()
      {
         int n = in.nextInt();
         
         for (int i = 1; i <= n; i++) g[i] = new ArrayList<Integer>();
         
         for (int i = 1; i <= n; i++) {
            
            int x = in.nextInt();
            
            if (x != - 1) g[i].add(x);
            
         }
         
         for (int i = 1; i <= n; i++) {
            dp[i] = Math.max(dp[i], 1); dfs(i, 0);
         }
         
         out.println(ans);
         
         out.close();
      }
      
   }

   static class InputReader
   {
      private InputStream stream;
      private byte[] buf = new byte[2048];
      private int curChar;
      private int numChars;
 
      public InputReader(InputStream stream)
      {
         this.stream = stream;
      }
 
      public int read()
      {
         if (numChars == -1)
            throw new UnknownError();
         if (curChar >= numChars)
         {
            curChar = 0;
            try
            {
               numChars = stream.read(buf);
            }
            catch (IOException e)
            {
               throw new UnknownError();
            }
            if (numChars <= 0)
               return -1;
         }
         return buf[curChar++];
      }
 
      public int peek()
      {
         if (numChars == -1)
            return -1;
         if (curChar >= numChars)
         {
            curChar = 0;
            try
            {
               numChars = stream.read(buf);
            }
            catch (IOException e)
            {
               return -1;
            }
            if (numChars <= 0)
               return -1;
         }
         return buf[curChar];
      }
 
      public void skip(int x)
      {
         while (x-- > 0)
            read();
      }
 
      public int nextInt()
      {
         return Integer.parseInt(next());
      }
 
      public long nextLong()
      {
         return Long.parseLong(next());
      }
 
      public String nextString()
      {
         return next();
      }
 
      public String next()
      {
         int c = read();
         while (isSpaceChar(c))
            c = read();
         StringBuffer res = new StringBuffer();
         do
         {
            res.appendCodePoint(c);
            c = read();
         }
         while (!isSpaceChar(c));
 
         return res.toString();
      }
 
      public String nextLine()
      {
         StringBuffer buf = new StringBuffer();
         int c = read();
         while (c != '\n' && c != -1)
         {
            if (c != '\r')
               buf.appendCodePoint(c);
            c = read();
         }
         return buf.toString();
      }
 
      public double nextDouble()
      {
         int c = read();
         while (isSpaceChar(c))
            c = read();
         int sgn = 1;
         if (c == '-')
         {
            sgn = -1;
            c = read();
         }
         double res = 0;
         while (!isSpaceChar(c) && c != '.')
         {
            if (c == 'e' || c == 'E')
               return res * Math.pow(10, nextInt());
            if (c < '0' || c > '9')
               throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
         }
         if (c == '.')
         {
            c = read();
            double m = 1;
            while (!isSpaceChar(c))
            {
               if (c == 'e' || c == 'E')
                  return res * Math.pow(10, nextInt());
               if (c < '0' || c > '9')
                  throw new InputMismatchException();
               m /= 10;
               res += (c - '0') * m;
               c = read();
            }
         }
         return res * sgn;
      }
 
      public boolean hasNext()
      {
         int value;
         while (isSpaceChar(value = peek()) && value != -1)
            read();
         return value != -1;
      }
 
      private boolean isSpaceChar(int c)
      {
         return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
      }
 
   }
}