#include <vector>
#include <string>
#include <cstring>
#include <queue>
#include <iostream>
#include <fstream>
#include <algorithm>
#include <cmath>

using namespace std;

int nextInt() {
    int x;
    scanf("%d", &x);
    return x;
}

char inp[10000];
string nextString() {
    scanf("%s", inp);
    return inp;
}

double nextDouble() {
    double x;
    scanf("%lf", &x);
    return x;
}

const int N = 1100;

void dfs1(int v, vector<vector<bool> > &adj, vector<bool> &used, vector<int> &order) {
    used[v] = true;
    for (int i = 0; i < adj[v].size(); ++i) {
        if (adj[v][i] && !used[i]) {
            dfs1(i, adj, used, order);
        }
    }
    order.push_back(v);
}

void dfs2(int v, vector<vector<bool> > &adj, vector<bool> &used, vector<int> &comp, int curComp) {
    used[v] = true;
    comp[v] = curComp;
    for (int i = 0; i < adj[v].size(); ++i) {
        if (adj[v][i] && !used[i]) {
            dfs2(i, adj, used, comp, curComp);
        }
    }
}

int main() {
    int n = nextInt();
    int m = nextInt();

    vector<vector<bool> > adj(n, vector<bool>(n, false));
    vector<vector<bool> > badj(n, vector<bool>(n, false));

    for (int i = 0; i < m; ++i) {
        int x = nextInt() - 1;
        int y = nextInt() - 1;
        adj[x][y] = true;
        badj[y][x] = true;
    }

    vector<int> order;
    vector<bool> used(n, false);
    for (int i = 0; i < n; ++i) {
        if (!used[i]) {
            dfs1(i, adj, used, order);
        }
    }

    fill(used.begin(), used.end(), false);
    vector<int> comp(n, -1);
    int compCount = 0;
    for (int t = n - 1; t >= 0; --t) {
        int i = order[t];
        if (!used[i]) {
            dfs2(i, badj, used, comp, ++compCount);
        }
    }

    vector<int> s(compCount, 0);
    for (int i = 0; i < n; ++i) {
        ++s[comp[i]];
    }
    vector<vector<int> > a(compCount, vector<int>(compCount, 0));
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            if (adj[i][j] && comp[i] != comp[j]) {
                a[comp[i]][comp[j]] = s[comp[i]];
            }
        }
    }

    vector<vector<int> > d(compCount, vector<int>(compCount, 1000000000));
    for (int i = 0; i < a.size(); ++i) {
        dij(i, a, d[i]);
    }

    int res = 0;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            if (adj[i][j] && d[comp[j]][comp[i]] + s[comp[i]] == w) {
                ++res;
            }
        }
    }



    return 0;
}