There is a directed graph G with N vertices and M edges. The vertices are numbered 1, 2, \ldots, N, and for each i (1 \leq i \leq M), the i-th directed edge goes from Vertex x_i to y_i. G does not contain directed cycles.

Find the length of the longest directed path in G. Here, the length of a directed path is the number of edges in it.

Constraints

* All values in input are integers.
* 2 \leq N \leq 10^5
* 1 \leq M \leq 10^5
* 1 \leq x_i, y_i \leq N
* All pairs (x_i, y_i) are distinct.
* G does not contain directed cycles.

Input

Input is given from Standard Input in the following format:


N M
x_1 y_1
x_2 y_2
:
x_M y_M


Output

Print the length of the longest directed path in G.

Examples

Input

4 5
1 2
1 3
3 2
2 4
3 4


Output

3


Input

6 3
2 3
4 5
5 6


Output

2


Input

5 8
5 3
2 3
2 4
5 2
5 1
1 4
4 3
1 3


Output

3
import java.util.*;
import java.io.*;
class Main{
  public static void main(String arg[])throws Exception{
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	String inps[] = br.readLine().split(" ");
    int n = Integer.parseInt(inps[0]);
    int m = Integer.parseInt(inps[1]);
    ArrayList <Integer> graph[] = new ArrayList[n];
    for(int i=0;i<n;i++)
      graph[i] = new ArrayList <Integer>();
    
    int degree[] = new int[n];
    for(int i=0;i<m;i++){
      inps = br.readLine().split(" ");
      int x = Integer.parseInt(inps[0]) - 1;
      int y = Integer.parseInt(inps[1]) - 1;
      graph[x].add(y);
      degree[y]++;
    }
    Queue <Node> bfs = new LinkedList();
    for(int i=0;i<n;i++)
      if(degree[i] == 0) bfs.add(new Node(i,1));
    int max_depth = 1;
    Node temp [] = new Node[n];
    for(int i=0;i<n;i++) temp[i] = new Node(i,1);
    while(!bfs.isEmpty()){
      Node curr = bfs.poll();
      for(int i=0;i<graph[curr.index].size();i++){
        Node c_temp = temp[graph[curr.index].get(i)];
        degree[c_temp.index]--;
        c_temp.depth = Math.max(c_temp.depth, curr.depth + 1);
        if(degree[c_temp.index] == 0) bfs.add(c_temp);
        max_depth = Math.max(max_depth, curr.depth + 1);
      }
    }
    
    System.out.println(max_depth-1);
    }
}
class Node{
  int depth;
  int index;
  public Node(int i, int d){
    depth = d;
    index = i;
  }
}