// Slower C++ solution:
//#pragma GCC target ("avx2,sse2")

//#pragma GCC optimization ("Ofast")

//#pragma GCC optimization ("unroll-loops")

#include <bits/stdc++.h>

#include <ext/pb_ds/assoc_container.hpp>

#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;



#define ordered_set tree <pair <ll, int>, null_type, less <pair <ll, int> >, rb_tree_tag, tree_order_statistics_node_update>

#define ll long long

#define ull unsigned long long

#define db long double

#define pb push_back

#define pf push_front

#define ppb pop_back

#define ppf pop_front

#define fi first

#define se second

#define mp make_pair

#define up_b upper_bound

#define low_b lower_bound

#define sz(x) (int)(x).size()

#define all(x) (x).begin(), (x).end()

#define endl "\n"



#define left fsdsdfoisf

#define sum dpsdfioppsf

#define assign xcvjlkdjfio

#define trie fksdfkjkfnjuiv

#define next sidlfjsfkl

#define merge sdfksdkfsldf



//#define int long long



using namespace std;



void dout() {

    cerr << endl;

}

template <typename Head, typename... Tail>

void dout(Head H, Tail... T) {

    cerr << H << ' ';

    dout(T...);

}



//mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

typedef pair <int, int> pii;



const int N = 1e5 + 7;

int n, m, dp[N];

vector <int> q[N], r[N], ord;

bool used[N];



void dfs(int v) {

    used[v] = true;

    for (auto i : q[v]) {

        if (!used[i]) {

            dfs(i);

        }

    }

    ord.pb(v);

}



void solve(int tc) {

    // check for (int i = 0; i < n; j++)

    cin >> n >> m;

    for (int i = 1; i <= m; i++) {

        int x, y;

        cin >> x >> y;

        q[x].pb(y);

        r[y].pb(x);

    }

    for (int i = 1; i <= n; i++) {

        if (!used[i]) {

            dfs(i);

        }

    }

    reverse(all(ord));

    int res = 0;

    for (int i = 1; i <= n; i++) {

        int v = ord[i - 1];

        for (auto j : r[v]) {

            dp[v] = max(dp[v], dp[j] + 1);

        }

        res = max(res, dp[v]);

    }

    cout << res;

}



signed main() {

    ios_base::sync_with_stdio(false);

    cin.tie(NULL);

//    freopen("input.txt", "r", stdin);

//    freopen("output.txt", "w", stdout);

    int tc = 1;

//    cin >> tc;

    for (int i = 0; i < tc; i++) {

        solve(i);

//        cleanup();

    }

}


// Faster C++ solution for the same problem (measured speedup: 1.6209556161314589x):
#include <bits/stdc++.h>



/**

       return NO_PAIN ? NO_GAIN : GAIN;

*/



using namespace std;



#define all(v)   v.begin(), v.end()

#define sz(x)    (int) x.size()

#define Unique(x) x.erase(unique(all(x)), x.end())

#define endl "\n"

#define pb push_back

#define START cin.tie(0); cout.tie(0); ios_base::sync_with_stdio(0);

#define isOdd(n)    (n&1)

#define pow(n, m) (ll)powl(n, m)

#define numOfDigits(n)  ((n)? (ll)(log10(n))+1 : 1)

#define clr(x, val)    memset(x, val, sizeof(x)) //be careful of value and TLE

#define MOD 1000000007

#define EPS 1e-7

#define LSOne(x)  (x & (-x))   //least significant 1

typedef long long ll;

typedef long double ld;

typedef pair<int, int> pii;

typedef vector<int> vi;



const int N = 1e5 + 1;

vector<vi> adj(N);

bool vis[N];

int dp[N];

void dfs(int u){

    /*

    for each vertex, ask it what is the longest path for you.

     then his parent's longest path is max + 1

    */

    vis[u] = 1;

    for(int i = 0; i<sz(adj[u]); i++){

        int v = adj[u][i];

        if(!vis[v])

            dfs(v);

        dp[u] = max(dp[u], dp[v] + 1);

    }

}

int main()

{

    START

    //freopen("test cases\\in.txt", "r", stdin) ;

    //freopen("test cases\\in.txt", "w", stdout);

    int n, m; cin>>n>>m;



    for(int i = 0; i<m; i++){

        int u, v; cin>>u>>v;

        adj[u].pb(v);

    }

    int mx = 0;

    for(int i = 1; i<=n; i++)

        if(!vis[i] && sz(adj[i]))

            dfs(i);



    cout<<*max_element(dp, dp+N);

	return 0;

}