#include <bits/stdc++.h>
#include <unordered_map>

#define int int64_t
#define all(x) begin(x),end(x)
#define F(i, n) for(int i = 0; i < n; ++ i)

using namespace std;

vector < vector<int> > g, gr;
vector<char> used;
vector<int> order, component;
vector<vector<int> > components;
vector<int> o;

void dfs1 (int v) {
	used[v] = true;
	for (size_t i=0; i<g[v].size(); ++i)
		if (!used[ g[v][i] ])
			dfs1 (g[v][i]);
	order.push_back (v);
}

void dfs2 (int v) {
	used[v] = true;
	component.push_back (v);
	for (size_t i=0; i<gr[v].size(); ++i)
		if (!used[ gr[v][i] ])
			dfs2 (gr[v][i]);
}

vector<pair<int, int> > edges0;
set<pair<int, int> > st;

vector<vector<int> > d;

int32_t main() {
    ios_base::sync_with_stdio(false);
    int n, m;
    cin >> n >> m;
    d.resize(n);
    g.resize(n);
    gr.resize(n);
    o.resize(n);
    F(i, m) {
		int a, b;
		cin >> a >> b;
		-- a; -- b;
		g[a].push_back(b);
		gr[b].push_back(a);
		edges0.push_back({a, b});
	}

	used.assign (n, false);
	for (int i=0; i < n; ++i) {
		if (!used[i]) {
			dfs1(i);
		}
	}
	used.assign (n, false);
	F(i, n) {
		int v = order[n-1-i];
		if (!used[v]) {
			dfs2 (v);
			F(e, component.size()) {
                o[component[e]] = components.size();
			}
			components.push_back(component);
			component.clear();
		}
	}
	F(e, edges0.size()) {
	    int A = o[edges0[e].first];
	    int B = o[edges0[e].second];
        if(A == B) continue;
        st.insert({A, B});
	}
	vector<int> cnt(components.size());
	for(set<pair<int, int> >::iterator iter = st.begin(); iter!=st.end(); ++ iter) {
        d[iter->second].push_back(iter->first);
        ++ cnt[iter->first];
	}
	queue<int> q;
	F(i, components.size()) if(!cnt[i]) q.push(i);
	vector<int> dp(n);
	int ans = 0;
	while(q.size()) {
        int t = q.front();
        q.pop();
        dp[t] += components[t].size();
        ans += ((int)1 - d[t].size()) * dp[t] * dp[t];
        F(i, d[t].size()) {
            int e = d[t][i];
            dp[e] += dp[t];
            -- cnt[e];
            if(cnt[e] == 0) q.push(e);
        }
	}
	cout << ans;
}