stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#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;

}


// Faster C++ solution for the same problem (measured speedup: 1.1246115747228957x):
#include<cstdio>

#include<cstring>

#include<iostream>

#include<algorithm>

#include<vector>

#include<queue>

using namespace std;

const int maxn = 1e5 + 5;

vector<int>G[maxn];

queue<int>q;

int in[maxn];

int main(){

	int  n,m;

	scanf("%d%d",&n,&m);

	int x,y;

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

		scanf("%d%d",&x,&y);

		G[x].push_back(y);

		in[y]++;

	}

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

		if(in[i] == 0) q.push(i);

	}

	int ans = 0;

	while(!q.empty()){

		int cnt = q.size();

		//cout << cnt << endl;

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

		int cur = q.front();

		q.pop();

		int len = G[cur].size();

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

			int tmp = G[cur][i];

			in[tmp]--;

			if(in[tmp] == 0) q.push(tmp);

		}

		}

		ans++;

	}

	ans--;

	printf("%d\n",ans);

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std ;

#define ll long long



inline int D(){

    int t ;

    scanf( "%d" , &t ) ;

    return t ;

}

inline ll LLD(){

    ll t ;

    scanf( "%lld" , &t ) ;

    return t ;

}

//const int INF = 0x3f3f3f3f;

//const int mod=1e9+7;

//###################################################################

const int N=100009;

int n,m;

vector<vector<int>>g(N);



int mem[N];

int solve(int num){

    if(mem[num]!=-1)return mem[num];

    if(g[num].size()) {

        int ret=0;

        for (auto i:g[num]) {

            ret =max(ret,solve(i));

        }

        return mem[num]=1+ret;

    }

    return mem[num]=0;



}



int main(){

    n=D(),m=D();

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

        int u=D(),v=D();

        g[u].push_back(v);

    }

    int mx=0;

    memset(mem,-1,sizeof(mem));

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

        mx=max(mx,solve(i));

    }

    printf("%d",mx);

}

// Faster C++ solution for the same problem (measured speedup: 1.1179797707898165x):
#include<cstdio>

#include<cstring>

#include<iostream>

#include<algorithm>

#include<vector>

#include<queue>

using namespace std;

const int maxn = 1e5 + 5;

vector<int>G[maxn];

queue<int>q;

int in[maxn];

int main(){

	int  n,m;

	scanf("%d%d",&n,&m);

	int x,y;

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

		scanf("%d%d",&x,&y);

		G[x].push_back(y);

		in[y]++;

	}

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

		if(in[i] == 0) q.push(i);

	}

	int ans = 0;

	while(!q.empty()){

		int cnt = q.size();

		//cout << cnt << endl;

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

		int cur = q.front();

		q.pop();

		int len = G[cur].size();

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

			int tmp = G[cur][i];

			in[tmp]--;

			if(in[tmp] == 0) q.push(tmp);

		}

		}

		ans++;

	}

	ans--;

	printf("%d\n",ans);

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



vector <int> dp[100010], ed[100010];



int solve(int i, int j){

	

	if(j == (int)ed[i].size()) return 0;

	

	if(dp[i][j] == -1) dp[i][j] = max(solve(ed[i][j], 0) + 1, solve(i, j + 1));

	

	return dp[i][j];

}

	



int main(){

	

	int n, m, ans = 0;

	scanf("%d %d", &n, &m);

	

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

		int a, b;

		scanf(" %d %d", &a, &b);

		

		ed[a].push_back(b);

		dp[a].push_back(-1);

	}

	

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

		for(int j = 0; j < (int)ed[i].size(); j++){

			if(dp[i][j] == -1) solve(i, j);

			

			ans = max(dp[i][j], ans);

		}

	}

	

	printf("%d\n", ans);	

	

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.8106996852039747x):
#include<cstdio>

#include<cstring>

#include<iostream>

#include<algorithm>

#include<vector>

#include<queue>

using namespace std;

const int maxn = 1e5 + 5;

vector<int>G[maxn];

queue<int>q;

int in[maxn];

int main(){

	int  n,m;

	scanf("%d%d",&n,&m);

	int x,y;

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

		scanf("%d%d",&x,&y);

		G[x].push_back(y);

		in[y]++;

	}

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

		if(in[i] == 0) q.push(i);

	}

	int ans = 0;

	while(!q.empty()){

		int cnt = q.size();

		//cout << cnt << endl;

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

		int cur = q.front();

		q.pop();

		int len = G[cur].size();

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

			int tmp = G[cur][i];

			in[tmp]--;

			if(in[tmp] == 0) q.push(tmp);

		}

		}

		ans++;

	}

	ans--;

	printf("%d\n",ans);

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



int N, M, a, b, ans;

vector<int> V[100100];

int dp[100100];



int f(int a) {

	if (V[a].size() == 0) return 0;

	if (dp[a] != -1) return dp[a];

	dp[a] = 0;

	for(int i=0; i<V[a].size(); i++) {

		int b = V[a][i];

		dp[a] = max(dp[a], f(b)+1);

	}

	return dp[a];

}



int main() {

	cin >> N >> M;

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

		cin >> a >> b;

		V[a].push_back(b);

	}

	memset(dp, -1, sizeof(dp));

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

		ans = max(ans, f(i));

	}

	cout << ans << endl;

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.1115209699021014x):
//拓扑排序+dp 

#include <bits/stdc++.h>

using namespace std;

const int maxn = 100025;

int dp[maxn],in[maxn];

vector<int> G[maxn];

int main()

{

    queue<int> q;

    int n,m,a,b,ans = 0;

	cin>>n>>m;

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

    	cin>>a>>b;

		in[b]++;

		G[a].push_back(b);

	}

	

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

	    if(!in[i]) q.push(i);

	    

    while(!q.empty()){

        int now = q.front();

        q.pop();

        int sz = G[now].size();

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

            dp[G[now][i]] = max(dp[G[now][i]],dp[now]+1);

            in[G[now][i]]--;

            if(in[G[now][i]]==0) q.push(G[now][i]);

        }

    }

    for(int i = 1;i<=n;++i) ans = max(ans,dp[i]);

    cout<<ans<<endl;

    return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

#define N (int)2e5

#define fi first

#define se second

#define mp make_pair

#define pb push_back

int n,m,memo[N];

vector <int> adj[N];



int dp(int u) {

    if (adj[u].size() == 0) return 0;

    int &sol = memo[u];

    if (sol != -1) return sol;

    int keep = INT_MIN;

    for (int v : adj[u]) {

        keep = max(

            keep ,

            dp(v) + 1

        );

    }

    return sol = keep;

}



int main() {

    scanf("%d%d" , &n , &m);

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

        int u,v; scanf("%d%d" , &u , &v);

        adj[u].pb(v);

    }

    memset (memo , -1 , sizeof memo);

    int sol = INT_MIN;

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

        sol = max(sol , dp(u));

    printf("%d\n" , sol);

}


// Faster C++ solution for the same problem (measured speedup: 2.082814289900274x):
//拓扑排序+dp 

#include <bits/stdc++.h>

using namespace std;

const int maxn = 100025;

int dp[maxn],in[maxn];

vector<int> G[maxn];

int main()

{

    queue<int> q;

    int n,m,a,b,ans = 0;

	cin>>n>>m;

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

    	cin>>a>>b;

		in[b]++;

		G[a].push_back(b);

	}

	

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

	    if(!in[i]) q.push(i);

	    

    while(!q.empty()){

        int now = q.front();

        q.pop();

        int sz = G[now].size();

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

            dp[G[now][i]] = max(dp[G[now][i]],dp[now]+1);

            in[G[now][i]]--;

            if(in[G[now][i]]==0) q.push(G[now][i]);

        }

    }

    for(int i = 1;i<=n;++i) ans = max(ans,dp[i]);

    cout<<ans<<endl;

    return 0;

}
// 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.8148563434376097x):
//拓扑排序+dp 

#include <bits/stdc++.h>

using namespace std;

const int maxn = 100025;

int dp[maxn],in[maxn];

vector<int> G[maxn];

int main()

{

    queue<int> q;

    int n,m,a,b,ans = 0;

	cin>>n>>m;

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

    	cin>>a>>b;

		in[b]++;

		G[a].push_back(b);

	}

	

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

	    if(!in[i]) q.push(i);

	    

    while(!q.empty()){

        int now = q.front();

        q.pop();

        int sz = G[now].size();

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

            dp[G[now][i]] = max(dp[G[now][i]],dp[now]+1);

            in[G[now][i]]--;

            if(in[G[now][i]]==0) q.push(G[now][i]);

        }

    }

    for(int i = 1;i<=n;++i) ans = max(ans,dp[i]);

    cout<<ans<<endl;

    return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

#define fast ios_base::sync_with_stdio(false),cin.tie(NULL)

#define INF 1e18

int n, m;

vector<int> graph[100020];

vector<int> dp(100020, -1);

vector<bool> visited(100020, false);

int dfs(int node, int sum)

{

    if(dp[node] != -1)

        return dp[node];

    if(graph[node].empty())

        return 1;

    else{

        int temp, max = 0;

        for (auto child : graph[node]) {

            temp = dfs(child, sum+1);

            if(temp > max)

                max = temp;

        }

        return dp[node] = max+1;

    }

}

int check()

{

    int mx = 0;

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

        if(!visited[i])

            mx = max(mx, dfs(i, 0));

    }

    return mx-1;

}

int main() {

    fast;

    cin>>n>>m;

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

        int a, b;

        cin>>a>>b;

        graph[a].push_back(b);

    }

    cout<<check();

}

// Faster C++ solution for the same problem (measured speedup: 1.1228373323819691x):
//拓扑排序+dp 

#include <bits/stdc++.h>

using namespace std;

const int maxn = 100025;

int dp[maxn],in[maxn];

vector<int> G[maxn];

int main()

{

    queue<int> q;

    int n,m,a,b,ans = 0;

	cin>>n>>m;

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

    	cin>>a>>b;

		in[b]++;

		G[a].push_back(b);

	}

	

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

	    if(!in[i]) q.push(i);

	    

    while(!q.empty()){

        int now = q.front();

        q.pop();

        int sz = G[now].size();

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

            dp[G[now][i]] = max(dp[G[now][i]],dp[now]+1);

            in[G[now][i]]--;

            if(in[G[now][i]]==0) q.push(G[now][i]);

        }

    }

    for(int i = 1;i<=n;++i) ans = max(ans,dp[i]);

    cout<<ans<<endl;

    return 0;

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

#define mx 200005

vector<int>adj[mx];

bool vis[mx];

int dp[mx];



void dfs(int src){

vis[src] = 1;



for(int i = 0;i<adj[src].size(); i++){

    if(!vis[adj[src][i]])

        dfs(adj[src][i]);

dp[src] = max(dp[src],1 + dp[adj[src][i]]);

}

}

int longest_path(int n){

    int ans = 0;

    memset(dp,0,sizeof dp);

    memset(vis,0,sizeof vis);



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

        if(!vis[i])

            dfs(i);

    }

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

        ans = max(ans,dp[i]);

    }

return ans;

}









int main(){

int n,m;

cin>>n>>m;

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

    int x,y;

    cin>>x>>y;

    adj[x].push_back(y);

}



cout<<longest_path(n)<<endl;

}


// Faster C++ solution for the same problem (measured speedup: 2.1438010227135686x):
//拓扑排序+dp 

#include <bits/stdc++.h>

using namespace std;

const int maxn = 100025;

int dp[maxn],in[maxn];

vector<int> G[maxn];

int main()

{

    queue<int> q;

    int n,m,a,b,ans = 0;

	cin>>n>>m;

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

    	cin>>a>>b;

		in[b]++;

		G[a].push_back(b);

	}

	

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

	    if(!in[i]) q.push(i);

	    

    while(!q.empty()){

        int now = q.front();

        q.pop();

        int sz = G[now].size();

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

            dp[G[now][i]] = max(dp[G[now][i]],dp[now]+1);

            in[G[now][i]]--;

            if(in[G[now][i]]==0) q.push(G[now][i]);

        }

    }

    for(int i = 1;i<=n;++i) ans = max(ans,dp[i]);

    cout<<ans<<endl;

    return 0;

}
// Slower C++ solution:
#include <iostream>

#include <stdio.h>

#include <string>

#include <cstring>

#include <cstdio>

#include <algorithm>

#include <cmath>

#include <vector>

#include <set> 

#include <map>

#include <queue>

#include <deque>

#include <stack>

#include <bitset>

#include <iomanip>

using namespace std;

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

#define ll long long

#define ull unsigned long long

#define ld long double

#define ii pair<int, int>

#define pll pair<ll, ll>

#define vii vector<ii>

#define f(i,a,b) for(int i=a; i<b; i++)

#define F first

#define S second

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

#define ReadFile freopen("input.txt","r",stdin)

#define WriteFile freopen("output.txt","w",stdout)

int x[] = { 0, -1, 0, 1, -1, 1, -1, 1 };

int y[] = { -1, 0, 1, 0, 1, -1, -1, 1 };

const int MOD = 998244353, N = 2e5 + 5;

const double pi = acos(-1);



vector<int> graph[N];

bool vis[N];

int dp[N];



void dfs(int node)

{

	if (vis[node]) return;

	vis[node] = true;

	for (int child : graph[node])

	{

		if(!vis[child])dfs(child);

		dp[node] = max(dp[node], dp[child] + 1);

	}

}



int main()

{

	assem99;



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

	f(i, 0, m)

	{

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

		graph[u].push_back(v);

	}

	int ans = 0;

	f(i, 1, n + 1) if (!vis[i]) dfs(i);

	f(i, 1, n + 1) ans = max(ans, dp[i]);



	cout << ans;



	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.8335595060014287x):
//拓扑排序+dp 

#include <bits/stdc++.h>

using namespace std;

const int maxn = 100025;

int dp[maxn],in[maxn];

vector<int> G[maxn];

int main()

{

    queue<int> q;

    int n,m,a,b,ans = 0;

	cin>>n>>m;

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

    	cin>>a>>b;

		in[b]++;

		G[a].push_back(b);

	}

	

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

	    if(!in[i]) q.push(i);

	    

    while(!q.empty()){

        int now = q.front();

        q.pop();

        int sz = G[now].size();

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

            dp[G[now][i]] = max(dp[G[now][i]],dp[now]+1);

            in[G[now][i]]--;

            if(in[G[now][i]]==0) q.push(G[now][i]);

        }

    }

    for(int i = 1;i<=n;++i) ans = max(ans,dp[i]);

    cout<<ans<<endl;

    return 0;

}
// Slower C++ solution:
#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;

}


// Faster C++ solution for the same problem (measured speedup: 1.1196212440220359x):
//拓扑排序+dp 

#include <bits/stdc++.h>

using namespace std;

const int maxn = 100025;

int dp[maxn],in[maxn];

vector<int> G[maxn];

int main()

{

    queue<int> q;

    int n,m,a,b,ans = 0;

	cin>>n>>m;

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

    	cin>>a>>b;

		in[b]++;

		G[a].push_back(b);

	}

	

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

	    if(!in[i]) q.push(i);

	    

    while(!q.empty()){

        int now = q.front();

        q.pop();

        int sz = G[now].size();

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

            dp[G[now][i]] = max(dp[G[now][i]],dp[now]+1);

            in[G[now][i]]--;

            if(in[G[now][i]]==0) q.push(G[now][i]);

        }

    }

    for(int i = 1;i<=n;++i) ans = max(ans,dp[i]);

    cout<<ans<<endl;

    return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std ;

#define ll long long



inline int D(){

    int t ;

    scanf( "%d" , &t ) ;

    return t ;

}

inline ll LLD(){

    ll t ;

    scanf( "%lld" , &t ) ;

    return t ;

}

//const int INF = 0x3f3f3f3f;

//const int mod=1e9+7;

//###################################################################

const int N=100009;

int n,m;

vector<vector<int>>g(N);



int mem[N];

int solve(int num){

    if(mem[num]!=-1)return mem[num];

    if(g[num].size()) {

        int ret=0;

        for (auto i:g[num]) {

            ret =max(ret,solve(i));

        }

        return mem[num]=1+ret;

    }

    return mem[num]=0;



}



int main(){

    n=D(),m=D();

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

        int u=D(),v=D();

        g[u].push_back(v);

    }

    int mx=0;

    memset(mem,-1,sizeof(mem));

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

        mx=max(mx,solve(i));

    }

    printf("%d",mx);

}

// Faster C++ solution for the same problem (measured speedup: 1.1130188679336572x):
//拓扑排序+dp 

#include <bits/stdc++.h>

using namespace std;

const int maxn = 100025;

int dp[maxn],in[maxn];

vector<int> G[maxn];

int main()

{

    queue<int> q;

    int n,m,a,b,ans = 0;

	cin>>n>>m;

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

    	cin>>a>>b;

		in[b]++;

		G[a].push_back(b);

	}

	

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

	    if(!in[i]) q.push(i);

	    

    while(!q.empty()){

        int now = q.front();

        q.pop();

        int sz = G[now].size();

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

            dp[G[now][i]] = max(dp[G[now][i]],dp[now]+1);

            in[G[now][i]]--;

            if(in[G[now][i]]==0) q.push(G[now][i]);

        }

    }

    for(int i = 1;i<=n;++i) ans = max(ans,dp[i]);

    cout<<ans<<endl;

    return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



vector <int> dp[100010], ed[100010];



int solve(int i, int j){

	

	if(j == (int)ed[i].size()) return 0;

	

	if(dp[i][j] == -1) dp[i][j] = max(solve(ed[i][j], 0) + 1, solve(i, j + 1));

	

	return dp[i][j];

}

	



int main(){

	

	int n, m, ans = 0;

	scanf("%d %d", &n, &m);

	

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

		int a, b;

		scanf(" %d %d", &a, &b);

		

		ed[a].push_back(b);

		dp[a].push_back(-1);

	}

	

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

		for(int j = 0; j < (int)ed[i].size(); j++){

			if(dp[i][j] == -1) solve(i, j);

			

			ans = max(dp[i][j], ans);

		}

	}

	

	printf("%d\n", ans);	

	

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.802664919750545x):
//拓扑排序+dp 

#include <bits/stdc++.h>

using namespace std;

const int maxn = 100025;

int dp[maxn],in[maxn];

vector<int> G[maxn];

int main()

{

    queue<int> q;

    int n,m,a,b,ans = 0;

	cin>>n>>m;

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

    	cin>>a>>b;

		in[b]++;

		G[a].push_back(b);

	}

	

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

	    if(!in[i]) q.push(i);

	    

    while(!q.empty()){

        int now = q.front();

        q.pop();

        int sz = G[now].size();

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

            dp[G[now][i]] = max(dp[G[now][i]],dp[now]+1);

            in[G[now][i]]--;

            if(in[G[now][i]]==0) q.push(G[now][i]);

        }

    }

    for(int i = 1;i<=n;++i) ans = max(ans,dp[i]);

    cout<<ans<<endl;

    return 0;

}