stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

#define print printf("==================\n")

#define ll long long

#define pi acos(-1.0)

#define eps 1e-16

#define max3(a,b,c) max(a,max(b,c))

const ll INF = 1 << 30;

typedef pair<double, double  > payar;

typedef struct

{

    ll  x, y;

} point;

priority_queue<payar, vector<payar>,  greater<payar> > pq; ///accending

vector< pair<double,payar  > > vpp;

vector < payar >  vp;

vector<int>g[100005];

int ind[100005];

int vis[100005];

int dis[100005];



int dfs(int u)

{



    vis[u]=1;

    if(dis[u]!=-1)return dis[u];

    int maxi =0;

    for(auto it: g[u])

    {

       // static int k;

     //   cout<<k++<<" "<<it<<endl;



      dis[u]=  maxi=max(maxi,1+dfs(it) );

    }

    return maxi;

}

int main()

{



    int n, m ;

    cin>>n>>m;

    memset(dis,-1,sizeof dis);

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

    {

        int u, v;

        cin>>u>>v;

        g[u].push_back(v);

        ind[v]++;



    }

    int ans =0;

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

    {

        if(ind[i]==0 and vis[i]==0)

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

    }

    cout<<ans;

    return  0 ;

}


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

#include <cmath>

#include <algorithm>

#include<cmath>

#include <vector>

typedef long long ll;

using namespace std;

int dp[100005] , vis[100005];

vector<int>graph[100005];

void dfs(int node)

{

    vis[node] = 1;

    for (auto child : graph[node])

    {

        if (!vis [child])

            dfs(child);

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

    }

}

int main()

{

    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);

    int n, e,ans=0,u,v;

    cin >> n >> e;

    while (e--)

    {

        cin >> u >> v;

        graph[u].push_back(v);

    }

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

    {

        if (!vis[i])

            dfs(i);

    }

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

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

    cout << ans;

    return 0;

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

#define ll long long

using namespace std;

ll n,m,x,y;

vector<ll>v[100009];

ll dp[100009];



ll f(ll N){

	if (v[N].empty())return 0;

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

	ll z=0;

	for(int i=0; i<v[N].size(); i++){

		z=max(z,f(v[N][i])+1);

	}

	dp[N]=z;

	return dp[N];

}



int main(){

	cin >> n >> m;

	memset(dp,-1,sizeof dp);

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

		cin >> x >> y;

		v[x].push_back(y);

	}

	ll jwb=0;

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

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

	}

	cout << jwb << endl;

}

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

#include <cmath>

#include <algorithm>

#include<cmath>

#include <vector>

typedef long long ll;

using namespace std;

int dp[100005] , vis[100005];

vector<int>graph[100005];

void dfs(int node)

{

    vis[node] = 1;

    for (auto child : graph[node])

    {

        if (!vis [child])

            dfs(child);

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

    }

}

int main()

{

    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);

    int n, e,ans=0,u,v;

    cin >> n >> e;

    while (e--)

    {

        cin >> u >> v;

        graph[u].push_back(v);

    }

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

    {

        if (!vis[i])

            dfs(i);

    }

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

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

    cout << ans;

    return 0;

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

#define ll long long

using namespace std;

ll n,m,x,y;

vector<ll>v[100009];

ll dp[100009];



ll f(ll N){

	if (v[N].empty())return 0;

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

	ll z=0;

	for(int i=0; i<v[N].size(); i++){

		z=max(z,f(v[N][i])+1);

	}

	dp[N]=z;

	return dp[N];

}



int main(){

	cin >> n >> m;

	memset(dp,-1,sizeof dp);

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

		cin >> x >> y;

		v[x].push_back(y);

	}

	ll jwb=0;

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

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

	}

	cout << jwb << endl;

}//z

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

#include <cmath>

#include <algorithm>

#include<cmath>

#include <vector>

typedef long long ll;

using namespace std;

int dp[100005] , vis[100005];

vector<int>graph[100005];

void dfs(int node)

{

    vis[node] = 1;

    for (auto child : graph[node])

    {

        if (!vis [child])

            dfs(child);

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

    }

}

int main()

{

    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);

    int n, e,ans=0,u,v;

    cin >> n >> e;

    while (e--)

    {

        cin >> u >> v;

        graph[u].push_back(v);

    }

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

    {

        if (!vis[i])

            dfs(i);

    }

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

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

    cout << ans;

    return 0;

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





using namespace std;



vector<int> v[100005];

bool processado[100005];

int tab[100005];



int dfs(int s)

{



    //processado[s] = true;

    int soma, max = 0, entrou = 0;

    

    if(tab[s] >= 0)

    {

        return tab[s];

    }

    for (int i = 0; i < v[s].size(); ++i)

    {



        entrou = 1;

        soma = dfs(v[s][i]) + 1;

        if(soma > max)

        {

            max = soma;

            tab[s] = max;

        }

    }

    if(entrou == 1)

    {

        return max;

    }



    return tab[s] = 0;



}

 





int main(){



    int n, m;

    cin >> n >> m;

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



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

    {

        processado[i] = false;

    }*/



    int x, y;

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

    {

        cin >> x >> y;

        v[x].push_back(y);

    }



    int soma = 0;

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

    {

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

    }



    cout << soma << endl;











    



    

    return 0;

}


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

#include <cmath>

#include <algorithm>

#include<cmath>

#include <vector>

typedef long long ll;

using namespace std;

int dp[100005] , vis[100005];

vector<int>graph[100005];

void dfs(int node)

{

    vis[node] = 1;

    for (auto child : graph[node])

    {

        if (!vis [child])

            dfs(child);

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

    }

}

int main()

{

    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);

    int n, e,ans=0,u,v;

    cin >> n >> e;

    while (e--)

    {

        cin >> u >> v;

        graph[u].push_back(v);

    }

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

    {

        if (!vis[i])

            dfs(i);

    }

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

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

    cout << ans;

    return 0;

}
// Slower C++ solution:
/**

     **author : _KMS_

     **created : 30-03-2020

**/

#include<bits/stdc++.h>

using namespace std;

const long long M =3e5+10,MOD=1e9+7;

typedef long long ll;

vector<int>v[M];

bool vis[M];

int dp[M];

void dfs(int i)

{

  vis[i]=1;

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

  {

    int y=v[i][j];

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

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

  }

}

int main()

{

    ios::sync_with_stdio(false);

    cin.tie(0);

     int n,m;

     cin>>n>>m;

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

     {

       int x,y;

       cin>>x>>y;

       v[x].push_back(y);

     }

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

     {

      if(!vis[i])

      {

        dfs(i);

      }

     }

    sort(dp+1,dp+n+1);

    cout<<dp[n]<<"\n";

    return 0;

}

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

#include <cmath>

#include <algorithm>

#include<cmath>

#include <vector>

typedef long long ll;

using namespace std;

int dp[100005] , vis[100005];

vector<int>graph[100005];

void dfs(int node)

{

    vis[node] = 1;

    for (auto child : graph[node])

    {

        if (!vis [child])

            dfs(child);

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

    }

}

int main()

{

    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);

    int n, e,ans=0,u,v;

    cin >> n >> e;

    while (e--)

    {

        cin >> u >> v;

        graph[u].push_back(v);

    }

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

    {

        if (!vis[i])

            dfs(i);

    }

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

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

    cout << ans;

    return 0;

}
// Slower C++ solution:
/**

     **author : _KMS_

     **created : 30-03-2020

**/

#include<bits/stdc++.h>

using namespace std;

const long long M =3e5+10,MOD=1e9+7;

typedef long long ll;

vector<int>v[M];

bool vis[M];

int dp[M];

void dfs(int i)

{

  vis[i]=1;

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

  {

    int y=v[i][j];

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

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

  }

}

int main()

{

    ios::sync_with_stdio(false);

    cin.tie(0);

     int n,m;

     cin>>n>>m;

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

     {

       int x,y;

       cin>>x>>y;

       v[x].push_back(y);

     }

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

     {

      if(!vis[i])

      {

        dfs(i);

      }

     }

    sort(dp+1,dp+n+1);

    cout<<dp[n]<<"\n";

    return 0;

}

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

#define ll long long



using namespace std;

int dp[200005],n,m;

vector <int> DAG[200005];

int dfs(int x)

{

    if(dp[x]!=-1)

        return dp[x];

    int retVal=0;

    for(int i=0;i<DAG[x].size();i++)

    {   int child=DAG[x][i];

        retVal=max(retVal,dfs(child)+1);

    }

    dp[x]=retVal;

    return dp[x];

}

int main()

{

    cin>>n>>m;

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

    {

        int x,y;

        cin>>x>>y;

        DAG[x].push_back(y);

    }

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

    int longestPath=0;

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

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



    cout << longestPath << endl;



    return 0;

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

using namespace std;

#define print printf("==================\n")

#define ll long long

#define pi acos(-1.0)

#define eps 1e-16

#define max3(a,b,c) max(a,max(b,c))

const ll INF = 1 << 30;

typedef pair<double, double  > payar;

typedef struct

{

    ll  x, y;

} point;

priority_queue<payar, vector<payar>,  greater<payar> > pq; ///accending

vector< pair<double,payar  > > vpp;

vector < payar >  vp;

vector<int>g[100005];

int ind[100005];

int vis[100005];

int dis[100005];



int dfs(int u)

{



    vis[u]=1;

    if(dis[u]!=-1)return dis[u];

    int maxi =0;

    for(auto it: g[u])

    {

       // static int k;

     //   cout<<k++<<" "<<it<<endl;



      dis[u]=  maxi=max(maxi,1+dfs(it) );

    }

    return maxi;

}

int main()

{



    int n, m ;

    cin>>n>>m;

    memset(dis,-1,sizeof dis);

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

    {

        int u, v;

        cin>>u>>v;

        g[u].push_back(v);

        ind[v]++;



    }

    int ans =0;

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

    {

        if(ind[i]==0 and vis[i]==0)

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

    }

    cout<<ans;

    return  0 ;

}


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

#include <vector>

#include <map>

#include <algorithm>

#define ll long long



using namespace std;



int n, m, x, y, mx = 0;

vector<int> graph[100005];

int dp[100005];

bool vis[100005];



int dfs(int node)

{

	if (vis[node])return dp[node];

	vis[node] = 1;

	for (int i = 0; i < graph[node].size(); i++)

	{

		int child = graph[node][i];

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

	}

	return dp[node];

}



int main()

{

	cin >> n >> m;

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

	{

		cin >> x >> y;

		graph[x].push_back(y);

	}

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

	{

		if (!vis[i])

		{

			int l = dfs(i);

		}

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

	}

	cout << mx << '\n';

	return 0;

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

#define ll long long

using namespace std;

ll n,m,x,y;

vector<ll>v[100009];

ll dp[100009];



ll f(ll N){

	if (v[N].empty())return 0;

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

	ll z=0;

	for(int i=0; i<v[N].size(); i++){

		z=max(z,f(v[N][i])+1);

	}

	dp[N]=z;

	return dp[N];

}



int main(){

	cin >> n >> m;

	memset(dp,-1,sizeof dp);

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

		cin >> x >> y;

		v[x].push_back(y);

	}

	ll jwb=0;

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

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

	}

	cout << jwb << endl;

}

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

#include <vector>

#include <map>

#include <algorithm>

#define ll long long



using namespace std;



int n, m, x, y, mx = 0;

vector<int> graph[100005];

int dp[100005];

bool vis[100005];



int dfs(int node)

{

	if (vis[node])return dp[node];

	vis[node] = 1;

	for (int i = 0; i < graph[node].size(); i++)

	{

		int child = graph[node][i];

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

	}

	return dp[node];

}



int main()

{

	cin >> n >> m;

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

	{

		cin >> x >> y;

		graph[x].push_back(y);

	}

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

	{

		if (!vis[i])

		{

			int l = dfs(i);

		}

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

	}

	cout << mx << '\n';

	return 0;

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

#define ll long long

using namespace std;

ll n,m,x,y;

vector<ll>v[100009];

ll dp[100009];



ll f(ll N){

	if (v[N].empty())return 0;

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

	ll z=0;

	for(int i=0; i<v[N].size(); i++){

		z=max(z,f(v[N][i])+1);

	}

	dp[N]=z;

	return dp[N];

}



int main(){

	cin >> n >> m;

	memset(dp,-1,sizeof dp);

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

		cin >> x >> y;

		v[x].push_back(y);

	}

	ll jwb=0;

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

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

	}

	cout << jwb << endl;

}//z

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

#include <vector>

#include <map>

#include <algorithm>

#define ll long long



using namespace std;



int n, m, x, y, mx = 0;

vector<int> graph[100005];

int dp[100005];

bool vis[100005];



int dfs(int node)

{

	if (vis[node])return dp[node];

	vis[node] = 1;

	for (int i = 0; i < graph[node].size(); i++)

	{

		int child = graph[node][i];

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

	}

	return dp[node];

}



int main()

{

	cin >> n >> m;

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

	{

		cin >> x >> y;

		graph[x].push_back(y);

	}

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

	{

		if (!vis[i])

		{

			int l = dfs(i);

		}

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

	}

	cout << mx << '\n';

	return 0;

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





using namespace std;



vector<int> v[100005];

bool processado[100005];

int tab[100005];



int dfs(int s)

{



    //processado[s] = true;

    int soma, max = 0, entrou = 0;

    

    if(tab[s] >= 0)

    {

        return tab[s];

    }

    for (int i = 0; i < v[s].size(); ++i)

    {



        entrou = 1;

        soma = dfs(v[s][i]) + 1;

        if(soma > max)

        {

            max = soma;

            tab[s] = max;

        }

    }

    if(entrou == 1)

    {

        return max;

    }



    return tab[s] = 0;



}

 





int main(){



    int n, m;

    cin >> n >> m;

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



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

    {

        processado[i] = false;

    }*/



    int x, y;

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

    {

        cin >> x >> y;

        v[x].push_back(y);

    }



    int soma = 0;

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

    {

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

    }



    cout << soma << endl;











    



    

    return 0;

}


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

#include <vector>

#include <map>

#include <algorithm>

#define ll long long



using namespace std;



int n, m, x, y, mx = 0;

vector<int> graph[100005];

int dp[100005];

bool vis[100005];



int dfs(int node)

{

	if (vis[node])return dp[node];

	vis[node] = 1;

	for (int i = 0; i < graph[node].size(); i++)

	{

		int child = graph[node][i];

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

	}

	return dp[node];

}



int main()

{

	cin >> n >> m;

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

	{

		cin >> x >> y;

		graph[x].push_back(y);

	}

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

	{

		if (!vis[i])

		{

			int l = dfs(i);

		}

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

	}

	cout << mx << '\n';

	return 0;

}
// Slower C++ solution:
/**

     **author : _KMS_

     **created : 30-03-2020

**/

#include<bits/stdc++.h>

using namespace std;

const long long M =3e5+10,MOD=1e9+7;

typedef long long ll;

vector<int>v[M];

bool vis[M];

int dp[M];

void dfs(int i)

{

  vis[i]=1;

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

  {

    int y=v[i][j];

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

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

  }

}

int main()

{

    ios::sync_with_stdio(false);

    cin.tie(0);

     int n,m;

     cin>>n>>m;

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

     {

       int x,y;

       cin>>x>>y;

       v[x].push_back(y);

     }

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

     {

      if(!vis[i])

      {

        dfs(i);

      }

     }

    sort(dp+1,dp+n+1);

    cout<<dp[n]<<"\n";

    return 0;

}

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

#include <vector>

#include <map>

#include <algorithm>

#define ll long long



using namespace std;



int n, m, x, y, mx = 0;

vector<int> graph[100005];

int dp[100005];

bool vis[100005];



int dfs(int node)

{

	if (vis[node])return dp[node];

	vis[node] = 1;

	for (int i = 0; i < graph[node].size(); i++)

	{

		int child = graph[node][i];

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

	}

	return dp[node];

}



int main()

{

	cin >> n >> m;

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

	{

		cin >> x >> y;

		graph[x].push_back(y);

	}

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

	{

		if (!vis[i])

		{

			int l = dfs(i);

		}

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

	}

	cout << mx << '\n';

	return 0;

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

#define ll long long



using namespace std;

int dp[200005],n,m;

vector <int> DAG[200005];

int dfs(int x)

{

    if(dp[x]!=-1)

        return dp[x];

    int retVal=0;

    for(int i=0;i<DAG[x].size();i++)

    {   int child=DAG[x][i];

        retVal=max(retVal,dfs(child)+1);

    }

    dp[x]=retVal;

    return dp[x];

}

int main()

{

    cin>>n>>m;

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

    {

        int x,y;

        cin>>x>>y;

        DAG[x].push_back(y);

    }

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

    int longestPath=0;

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

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



    cout << longestPath << endl;



    return 0;

}


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

#include <vector>

#include <map>

#include <algorithm>

#define ll long long



using namespace std;



int n, m, x, y, mx = 0;

vector<int> graph[100005];

int dp[100005];

bool vis[100005];



int dfs(int node)

{

	if (vis[node])return dp[node];

	vis[node] = 1;

	for (int i = 0; i < graph[node].size(); i++)

	{

		int child = graph[node][i];

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

	}

	return dp[node];

}



int main()

{

	cin >> n >> m;

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

	{

		cin >> x >> y;

		graph[x].push_back(y);

	}

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

	{

		if (!vis[i])

		{

			int l = dfs(i);

		}

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

	}

	cout << mx << '\n';

	return 0;

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

using namespace std;

#define print printf("==================\n")

#define ll long long

#define pi acos(-1.0)

#define eps 1e-16

#define max3(a,b,c) max(a,max(b,c))

const ll INF = 1 << 30;

typedef pair<double, double  > payar;

typedef struct

{

    ll  x, y;

} point;

priority_queue<payar, vector<payar>,  greater<payar> > pq; ///accending

vector< pair<double,payar  > > vpp;

vector < payar >  vp;

vector<int>g[100005];

int ind[100005];

int vis[100005];

int dis[100005];



int dfs(int u)

{



    vis[u]=1;

    if(dis[u]!=-1)return dis[u];

    int maxi =0;

    for(auto it: g[u])

    {

       // static int k;

     //   cout<<k++<<" "<<it<<endl;



      dis[u]=  maxi=max(maxi,1+dfs(it) );

    }

    return maxi;

}

int main()

{



    int n, m ;

    cin>>n>>m;

    memset(dis,-1,sizeof dis);

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

    {

        int u, v;

        cin>>u>>v;

        g[u].push_back(v);

        ind[v]++;



    }

    int ans =0;

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

    {

        if(ind[i]==0 and vis[i]==0)

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

    }

    cout<<ans;

    return  0 ;

}


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

using namespace std;

#define ll long long

    const int N  = 1e5 + 5 ;

    vector < int > adj [ N ] ;

        bool visited[ N ]  ;

         int deg [ N] , dis[N];



         void dfs (int node ){

                if (!visited[node])

                    visited[node] = true;



                for ( int X : adj[node]){

                    dis[X] = max(dis[X] , dis[node] +1);

                    deg[X]--;

                    if (deg[X]==0)

                        dfs(X);

                }



         }



int main () {



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



            while (m--){

                int a , b ;

                 cin >> a >> b ;

                  adj[a].push_back(b);

                  deg[b]++;



            }

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

                if (!visited[i] && deg[i] == 0)

                    dfs(i);

            }

            int answer = 0 ;

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

                answer = max (answer,dis[i]);

            }

            cout << answer<<endl;







 return 0;

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

#define ll long long

using namespace std;

ll n,m,x,y;

vector<ll>v[100009];

ll dp[100009];



ll f(ll N){

	if (v[N].empty())return 0;

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

	ll z=0;

	for(int i=0; i<v[N].size(); i++){

		z=max(z,f(v[N][i])+1);

	}

	dp[N]=z;

	return dp[N];

}



int main(){

	cin >> n >> m;

	memset(dp,-1,sizeof dp);

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

		cin >> x >> y;

		v[x].push_back(y);

	}

	ll jwb=0;

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

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

	}

	cout << jwb << endl;

}

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

using namespace std;

#define ll long long

    const int N  = 1e5 + 5 ;

    vector < int > adj [ N ] ;

        bool visited[ N ]  ;

         int deg [ N] , dis[N];



         void dfs (int node ){

                if (!visited[node])

                    visited[node] = true;



                for ( int X : adj[node]){

                    dis[X] = max(dis[X] , dis[node] +1);

                    deg[X]--;

                    if (deg[X]==0)

                        dfs(X);

                }



         }



int main () {



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



            while (m--){

                int a , b ;

                 cin >> a >> b ;

                  adj[a].push_back(b);

                  deg[b]++;



            }

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

                if (!visited[i] && deg[i] == 0)

                    dfs(i);

            }

            int answer = 0 ;

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

                answer = max (answer,dis[i]);

            }

            cout << answer<<endl;







 return 0;

}