stablegradients/pie-gem5-pairs huggingface dataset:
// 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.8194569241862466x):
#include<bits/stdc++.h>

using namespace std;

typedef long long int ll;



vector<ll>adj[100005];

bool visited[100005];

ll dp[100005];



void dfs(ll s)

{

    ll len=1;

    visited[s]=true;

    for(auto x : adj[s])

    {

        if(visited[x]==false)

            dfs(x);



        dp[s]=max(dp[s],len+dp[x]);

    }

}





int main()

{

    ll n,m,x,y;

    cin>>n>>m;

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

    {

        cin>>x>>y;

        adj[x].push_back(y);

        //adj[y].push_back(x);

    }



    ll mx_len=0;



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

    {

        if(visited[i]==false)

        {

            dfs(i);

        }

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

    }





    cout<<mx_len<<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.1256836754734685x):
#include<bits/stdc++.h>

using namespace std;

typedef long long int ll;



vector<ll>adj[100005];

bool visited[100005];

ll dp[100005];



void dfs(ll s)

{

    ll len=1;

    visited[s]=true;

    for(auto x : adj[s])

    {

        if(visited[x]==false)

            dfs(x);



        dp[s]=max(dp[s],len+dp[x]);

    }

}





int main()

{

    ll n,m,x,y;

    cin>>n>>m;

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

    {

        cin>>x>>y;

        adj[x].push_back(y);

        //adj[y].push_back(x);

    }



    ll mx_len=0;



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

    {

        if(visited[i]==false)

        {

            dfs(i);

        }

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

    }





    cout<<mx_len<<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.149235463709225x):
#include<bits/stdc++.h>

using namespace std;

typedef long long int ll;



vector<ll>adj[100005];

bool visited[100005];

ll dp[100005];



void dfs(ll s)

{

    ll len=1;

    visited[s]=true;

    for(auto x : adj[s])

    {

        if(visited[x]==false)

            dfs(x);



        dp[s]=max(dp[s],len+dp[x]);

    }

}





int main()

{

    ll n,m,x,y;

    cin>>n>>m;

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

    {

        cin>>x>>y;

        adj[x].push_back(y);

        //adj[y].push_back(x);

    }



    ll mx_len=0;



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

    {

        if(visited[i]==false)

        {

            dfs(i);

        }

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

    }





    cout<<mx_len<<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.838207498441873x):
#include<bits/stdc++.h>

using namespace std;

typedef long long int ll;



vector<ll>adj[100005];

bool visited[100005];

ll dp[100005];



void dfs(ll s)

{

    ll len=1;

    visited[s]=true;

    for(auto x : adj[s])

    {

        if(visited[x]==false)

            dfs(x);



        dp[s]=max(dp[s],len+dp[x]);

    }

}





int main()

{

    ll n,m,x,y;

    cin>>n>>m;

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

    {

        cin>>x>>y;

        adj[x].push_back(y);

        //adj[y].push_back(x);

    }



    ll mx_len=0;



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

    {

        if(visited[i]==false)

        {

            dfs(i);

        }

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

    }





    cout<<mx_len<<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.1224594344714554x):
#include<bits/stdc++.h>

using namespace std;

typedef long long int ll;



vector<ll>adj[100005];

bool visited[100005];

ll dp[100005];



void dfs(ll s)

{

    ll len=1;

    visited[s]=true;

    for(auto x : adj[s])

    {

        if(visited[x]==false)

            dfs(x);



        dp[s]=max(dp[s],len+dp[x]);

    }

}





int main()

{

    ll n,m,x,y;

    cin>>n>>m;

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

    {

        cin>>x>>y;

        adj[x].push_back(y);

        //adj[y].push_back(x);

    }



    ll mx_len=0;



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

    {

        if(visited[i]==false)

        {

            dfs(i);

        }

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

    }





    cout<<mx_len<<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.1158403216510275x):
#include<bits/stdc++.h>

using namespace std;

typedef long long int ll;



vector<ll>adj[100005];

bool visited[100005];

ll dp[100005];



void dfs(ll s)

{

    ll len=1;

    visited[s]=true;

    for(auto x : adj[s])

    {

        if(visited[x]==false)

            dfs(x);



        dp[s]=max(dp[s],len+dp[x]);

    }

}





int main()

{

    ll n,m,x,y;

    cin>>n>>m;

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

    {

        cin>>x>>y;

        adj[x].push_back(y);

        //adj[y].push_back(x);

    }



    ll mx_len=0;



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

    {

        if(visited[i]==false)

        {

            dfs(i);

        }

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

    }





    cout<<mx_len<<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.8072345957780915x):
#include<bits/stdc++.h>

using namespace std;

typedef long long int ll;



vector<ll>adj[100005];

bool visited[100005];

ll dp[100005];



void dfs(ll s)

{

    ll len=1;

    visited[s]=true;

    for(auto x : adj[s])

    {

        if(visited[x]==false)

            dfs(x);



        dp[s]=max(dp[s],len+dp[x]);

    }

}





int main()

{

    ll n,m,x,y;

    cin>>n>>m;

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

    {

        cin>>x>>y;

        adj[x].push_back(y);

        //adj[y].push_back(x);

    }



    ll mx_len=0;



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

    {

        if(visited[i]==false)

        {

            dfs(i);

        }

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

    }





    cout<<mx_len<<endl;



    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.1071236984900203x):
#include <bits/stdc++.h>

using namespace std;



typedef long double LD;

typedef long long ll;

typedef map<int,int> mii;

typedef pair<int,int> pii;

typedef vector<pii> vpii;



#define pb              push_back

#define mp              make_pair

#define F               first

#define S               second

#define mod             1000000007

#define INF             2147483647

#define endl            "\n"

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

#define precision(a)    cout << fixed << setprecision(a)

#define bug(a,b)        cout<<a<<"\t"<<b<<"\n";

#define Case(a,b)       cout<<"Case "<<a<<": "<<b<<"\n";

#define reset(a,b)      memset(a,b,sizeof(a));

#define For(x,n)        for(int i=x; i<n; i++)



const int MAXN = 1000005;

const int SQRTN = 1003;

const int LOGN = 22;

const double PI=acos(-1);



int strtoint(string str){

    stringstream ss(str);

    int x = 0;

    ss >> x ;

    return x ;

}

string intostr(int x){

    stringstream ss;

    ss << x;

    string str = ss.str();

    return str;

}

void rem(string &s, const string &c) {

	auto pos = s.find(c);

	if (pos == string::npos) {

		cout << -1 << endl;

		exit(0);

	}

	s.erase(0, pos + 1);

}

void println (int n){

    cout<<n<<"\n";

}

void printvec(vector <int> &a){

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

        cout<<a[i]<<" ";

    }

    cout<<"\n";

}



void printgraph(vector <int> g[],int e){

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

        cout<<i<<" --> ";

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

            cout<<g[i][j]<<" ";

        }

        cout<<"\n";

    }

}



void printmap (map <int,int> &mymap){

    for (auto itr = mymap.begin(); itr != mymap.end(); ++itr) {

        cout << '\t' << itr->first

             << '\t' << itr->second << '\n';

    }

    cout << "\n";

}



vector <int> v[100005];

int dp [100005];

int visited [100005];

int temp=0;





int dfs (int k){

    if(visited[k]) return dp[k];



	visited[k] = 1;

	int res = 0;



	for(int i : v[k]){

		res = max(res, dfs(i) + 1 );

	}



	return dp[k] = res;

}



void solve(){

    int n,m;

    cin>>n>>m;

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

        int x,y;

        cin>>x>>y;

        v[x].pb(y);

    }

    int ans = 0;

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

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

    }

    cout<<ans<<endl;



    /*for (int i=0;i<n;i++){

        cout<<dp[i]<<" ";

    }*/

    //printgraph(v,n);





}





int main(){

    //FasterIO;



    solve();

    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: 1.8738466822780928x):
#include <bits/stdc++.h>

using namespace std;





#define clr(arr,val) memset(arr,val ,sizeof arr)

typedef  long long ull;

typedef long long ll;





ll const oo=1e9 ;

int const SZ= (int)1e5+3;

const ll mod=(ll)1e9+7;





vector<int> adj[SZ];

//int arr[100];

int dp[SZ];

int n,m;



int solve(int i){



    int &ret=dp[i];

    if(~ret) return ret;

    int mx=0;

    for(int x: adj[i]){

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

    }

    return ret=1+mx;

    

}

int main()

{

    

    cin>>n>>m;

    int u,v;

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

        cin>>u>>v; 

        adj[u].push_back(v);

    }

    clr(dp,-1);

    int mx=0;

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

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

    }

    

    cout<<mx-1<<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.6327728086236368x):
#include <bits/stdc++.h>

using namespace std;





#define clr(arr,val) memset(arr,val ,sizeof arr)

typedef  long long ull;

typedef long long ll;





ll const oo=1e9 ;

int const SZ= (int)1e5+3;

const ll mod=(ll)1e9+7;





vector<int> adj[SZ];

//int arr[100];

int dp[SZ];

int n,m;



int solve(int i){



    int &ret=dp[i];

    if(~ret) return ret;

    int mx=0;

    for(int x: adj[i]){

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

    }

    return ret=1+mx;

    

}

int main()

{

    

    cin>>n>>m;

    int u,v;

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

        cin>>u>>v; 

        adj[u].push_back(v);

    }

    clr(dp,-1);

    int mx=0;

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

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

    }

    

    cout<<mx-1<<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: 1.9287146498637409x):
#include <bits/stdc++.h>

using namespace std;





#define clr(arr,val) memset(arr,val ,sizeof arr)

typedef  long long ull;

typedef long long ll;





ll const oo=1e9 ;

int const SZ= (int)1e5+3;

const ll mod=(ll)1e9+7;





vector<int> adj[SZ];

//int arr[100];

int dp[SZ];

int n,m;



int solve(int i){



    int &ret=dp[i];

    if(~ret) return ret;

    int mx=0;

    for(int x: adj[i]){

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

    }

    return ret=1+mx;

    

}

int main()

{

    

    cin>>n>>m;

    int u,v;

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

        cin>>u>>v; 

        adj[u].push_back(v);

    }

    clr(dp,-1);

    int mx=0;

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

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

    }

    

    cout<<mx-1<<endl;

    

    return 0;

}