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.*;

public class Main {
    static ArrayList<edge>[]graph;
    public static void main(String[] args) throws IOException{
        BufferedReader f = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer st=new StringTokenizer(f.readLine());

        int n = Integer.parseInt (st.nextToken());
        int m = Integer.parseInt (st.nextToken());
        graph=new ArrayList[n];
        for(int i=0;i<n;i++)
            graph[i]=new ArrayList<>();
        for(int i=0;i<m;i++){
            st = new StringTokenizer (f.readLine());
            int a = Integer.parseInt (st.nextToken())-1;
            int b = Integer.parseInt (st.nextToken())-1;
            graph[a].add(new edge(b));
        }
        dp=new long[n];
        long ans=0;
        for(int i=0;i<n;i++){
            ans=Math.max(ans,solve(i));
        }
        ans--;
        System.out.println(ans);
        f.close();

        //print to System. out.println

    }
    static long []dp;
    public static long solve(int idx){
        long ret=1;
        long add=0;
        if(dp[idx]!=0){
            return dp[idx];
        }

        for(int i=0;i<graph[idx].size();i++){
            add=0;
            add+=solve(graph[idx].get(i).to);
            ret=Math.max(add+1,ret);
        }
        dp[idx]=ret;
        return ret;
    }
}
class edge{
    int to;
    edge(int a){
        to=a;
    }
}