#include <bits/stdc++.h>
using namespace std;

const int MAXN = 1000005;
const int MAXM = 1000005;

int n, m;
int head[MAXN], to[MAXM], nxt[MAXM], idx;  // 原图
int head2[MAXN], to2[MAXM], nxt2[MAXM], idx2; // 缩点后的图

// Tarjan 算法所需数组
int dfn[MAXN], low[MAXN], tim;
int stk[MAXN], top;
bool in_stk[MAXN];
int scc_id[MAXN], scc_cnt;
int scc_size[MAXN];  // 每个强连通分量的大小（环的长度）

// 拓扑排序 + DP 所需数组
int in_deg[MAXN];
int dp[MAXN]; // dp[i] 表示到达第i个强连通分量时，已经轰炸的最多轮数

// 加边函数（原图）
void add(int u, int v) {
    to[++idx] = v;
    nxt[idx] = head[u];
    head[u] = idx;
}

// 加边函数（缩点后的图）
void add2(int u, int v) {
    to2[++idx2] = v;
    nxt2[idx2] = head2[u];
    head2[u] = idx2;
    in_deg[v]++;  // 入度++
}

// Tarjan 算法求强连通分量
void tarjan(int u) {
    dfn[u] = low[u] = ++tim;
    stk[++top] = u;
    in_stk[u] = true;

    for (int i = head[u]; i; i = nxt[i]) {
        int v = to[i];
        if (!dfn[v]) {
            tarjan(v);
            low[u] = min(low[u], low[v]);
        } 
		else if (in_stk[v]) {
            low[u] = min(low[u], dfn[v]);
        }
    }

    if (dfn[u] == low[u]) {
        scc_cnt++;
        int v;
        do {
            v = stk[top--];
            in_stk[v] = false;
            scc_id[v] = scc_cnt;
            scc_size[scc_cnt]++;
        } while (v != u);
    }
}

int main() {
    cin>>n>>m;
    for (int i = 1; i <= m; i++) {
        int a, b;
        cin>>a>>b;
        add(a, b);
    }

    // 1. Tarjan 缩点
    for (int i = 1; i <= n; i++) 
        if (!dfn[i]) tarjan(i);


    // 2. 建缩点后的图 (DAG)
    for (int u = 1; u <= n; u++) {
        for (int i = head[u]; i; i = nxt[i]) {
            int v = to[i];
            if (scc_id[u] != scc_id[v]) {
                add2(scc_id[u], scc_id[v]);
            }
        }
    }

    // 3. 拓扑排序 + DP 求最长链
    queue<int> q;
    for (int i = 1; i <= scc_cnt; i++) {
        if (in_deg[i] == 0) {
            q.push(i);
            dp[i] = scc_size[i];  // 初始化dp值为该分量的大小
        }
    }

    int ans = 0;
    while (!q.empty()) {
        int u = q.front();
        q.pop();

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

        for (int i = head2[u]; i; i = nxt2[i]) {
            int v = to2[i];
            // dp[v] = max(dp[v], dp[u] + scc_size[v])
            if (dp[u] + scc_size[v] > dp[v]) {
                dp[v] = dp[u] + scc_size[v];
            }
            in_deg[v]--;
            if (in_deg[v] == 0) {
                q.push(v);
            }
        }
    }

    printf("%d\n", ans);
    return 0;
}