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 
#include <bits/stdc++.h>
using namespace std;
bool checkBit(long long n, int i) { return n & (1LL << i); }
long long setBit(long long n, int i) {
  return n | (1LL << i);
  ;
}
long long resetBit(long long n, int i) { return n & (~(1LL << i)); }
template <typename T>
T POW(T b, T p) {
  T r = 1;
  while (p) {
    if (p & 1) r = (r * b);
    b = (b * b);
    p >>= 1;
  }
  return r;
}
long long big_mod(long long n, long long p) {
  if (p == 0) return 1;
  if (!(p & 1)) {
    long long r = big_mod(n, p / 2) % 1000000007;
    return ((r % 1000000007) * (r % 1000000007)) % 1000000007;
  } else
    return ((n % 1000000007) * (big_mod(n, p - 1) % 1000000007)) % 1000000007;
}
long long gcd(long long a, long long b) {
  while (b != 0) {
    long long t = a % b;
    a = b;
    b = t;
  }
  return a;
}
vector<int> graph[2010];
int visit[2010];
int indegre[2010];
int depth[2010];
int maximum = 0;
void BFS(int source) {
  int group = 0;
  queue<int> q;
  q.push(source);
  visit[source] = 1;
  while (!q.empty()) {
    int top = q.front();
    q.pop();
    for (int j = 0; j < graph[top].size(); j++) {
      int v = graph[top][j];
      if (!visit[v]) {
        visit[v] = 1;
        depth[v] = depth[top] + 1;
        q.push(v);
        maximum = max(maximum, depth[v]);
      }
    }
  }
}
int main() {
  int n, edge;
  while (cin >> n) {
    int cnt = 0;
    for (int i = 0; i < (n); i++) {
      cin >> edge;
      if (edge >= 1) {
        graph[edge].push_back(i + 1);
        indegre[i + 1]++;
      }
    }
    for (int i = 1; i < (n + 1); i++)
      if (indegre[i] == 0) BFS(i);
    cout << maximum + 1 << endl;
    for (int i = 0; i < (n + 1); i++) {
      graph[i].clear();
    }
  }
}
