#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#ifdef LOC
#include "debuglib.h"
#else
#define deb(...)
#define DBP(...)
#endif
using namespace std;
using   ll         = long long;
using   Vi         = vector<int>;
using   Pii        = pair<int, int>;
#define pb           push_back
#define mp           make_pair
#define x            first
#define y            second
#define rep(i, b, e) for (int i = (b); i < (e); i++)
#define each(a, x)   for (auto& a : (x))
#define all(x)       (x).begin(), (x).end()
#define sz(x)        int((x).size())

mt19937 rnd;

int maxCutIters;
ll ans;

ll ch2(ll k) { return k * (k-1) / 2; }
ll ch3(ll k) { return k * (k-1) * (k-2) / 6; }

struct Triple {
	int x, y, z;
	bool operator<(const Triple& r) const {
		return make_tuple(x, y, z) < make_tuple(r.x, r.y, r.z);
	}
	bool operator==(const Triple& r) const {
		return x == r.x && y == r.y && z == r.z;
	}
};

struct DSU {
	Vi par, rank;

	DSU(int n = 0) {
		par.resize(n, -1);
		rank.resize(n);
	}

	int find(int v) {
		if (par[v] != -1) {
			par[v] = find(par[v]);
			return par[v];
		}
		return v;
	}

	bool join(int u, int v) {
		u = find(u);
		v = find(v);
		if (u == v) return 0;
		if (rank[u] < rank[v]) swap(u, v);
		rank[u] += (rank[u] == rank[v]);
		par[v] = u;
		return 1;
	}
};

namespace con4 {
	vector<Triple> edges;
	int n;

	vector<Triple> cuts;
	vector<vector<Pii>> T, G;
	DSU dsu;
	Vi anc, over;
	vector<bool> col;

	Vi dfs(int v, Pii p) {
		Vi ret;
		anc[v] = v;

		each(e, T[v]) if (e.x != p.x) {
			Vi other = dfs(e.x, {v, e.y});
			if (sz(ret) < sz(other)) ret.swap(other);
			each(i, other) ret.pb(i);
			dsu.join(v, e.x);
			anc[dsu.find(v)] = v;
			over[v] += over[e.x];
		}

		col[v] = 1;

		each(e, G[v]) {
			ret.pb(e.y);
			over[v]++;
			if (col[e.x]) {
				int lca = anc[dsu.find(e.x)];
				over[lca] -= 2;
			}
		}

		if (over[v] == 2) {
			Vi tmp;
			sort(all(ret));
			rep(i, 0, sz(ret)) {
				if ((i > 0 && ret[i] == ret[i-1]) || (i+1 < sz(ret) && ret[i] == ret[i+1])) {
					continue;
				}
				tmp.pb(ret[i]);
			}

			ret = tmp;
			assert(sz(ret) == 2);

			tmp.pb(p.y);
			sort(all(tmp));
			cuts.pb({tmp[0], tmp[1], tmp[2]});
		}

		return ret;
	}

	Vi mst;

	void processMst(const Vi& order) {
		mst.clear();
		T.assign(n, {});
		G.assign(n, {});
		dsu = {n};

		each(i, order) {
			auto& e = edges[i];
			if (dsu.join(e.x, e.y)) {
				T[e.x].pb({e.y, i});
				T[e.y].pb({e.x, i});
				mst.pb(i);
			} else {
				G[e.x].pb({e.y, i});
				G[e.y].pb({e.x, i});
			}
		}

		dsu = {n};
		anc.assign(n, -1);
		over.assign(n, 0);
		col.assign(n, 0);
		dfs(0, {-1, -1});
	}

	void solve() {
		if (n <= 1) return;

		int m = sz(edges);
		cuts.clear();

		Vi order(m);
		iota(all(order), 0);
		shuffle(all(order), rnd);
		processMst(order);

		constexpr double eps = 0.32;
		constexpr double alpha = 5;
		constexpr double teta = 0.08;

		vector<double> cover(m), dual(m);
		each(e, mst) cover[e] = 2;
		int iters = 0;
		double last_lambda = 50;

		while (true) {
			double lambda = *max_element(all(cover));
			//deb(iters, lambda);
			if (lambda < 1+eps) break;

			if (iters++ >= maxCutIters*4/5 || last_lambda-lambda < 0.01) {
#ifdef LOC
				assert(0);
#endif
				deb("nope :<", n);
				break;
			}

			rep(i, 0, m) {
				dual[i] = exp(alpha*cover[i]);
				cover[i] *= 1-teta;
			}

			sort(all(order), [&](int i, int j) { return dual[i] < dual[j]; });
			processMst(order);
			each(e, mst) cover[e] += teta*2;
		}

		//deb(n, m, maxCutIters, iters);

		while (iters < maxCutIters) {
			shuffle(all(order), rnd);
			processMst(order);
			iters++;
		}

		sort(all(cuts));
		cuts.erase(unique(all(cuts)), cuts.end());
		each(c, cuts) {
			ans += ll(edges[c.x].z) * edges[c.y].z * edges[c.z].z;
		}
	}
};

int n, m;
vector<vector<Pii>> G;
ll bridges;

namespace con3 {
	vector<bool> on;
	Vi active, deg, pre, low, nxt, siz;
	vector<Vi> comps, sigma;
	int cnt;

	vector<Pii> cycleStack;
	vector<vector<Pii>> cycles;
	vector<vector<Triple>> tri;
	Vi triNum, triPos, dep;

	void init() {
		on.resize(n);
		deg.resize(n);
		pre.resize(n);
		low.resize(n);
		nxt.resize(n);
		siz.resize(n);
		sigma.resize(n);
		triNum.resize(n);
		triPos.resize(n);
	}

	void save(int v) {
		comps.back().pb(v);
		each(e, sigma[v]) save(e);
	}

	void absorb(int dst, int begin, int end) {
		while (begin != end) {
			deg[dst] += deg[begin]-2;
			sigma[dst].pb(begin);
			begin = nxt[begin];
		}
	}

	void connect(int w, Pii v) {
		pre[w] = low[w] = cnt++;
		nxt[w] = -1;
		deg[w] = 0;
		siz[w] = 1;
		sigma[w].clear();

		each(u, G[w]) if (on[u.x]) {
			deg[w]++;
			if (pre[u.x] == -1) {
				connect(u.x, {w, u.y});
				siz[w] += siz[u.x];
				int pu = u.x;
				if (deg[u.x] == 2) {
					pu = nxt[u.x];
					comps.emplace_back();
					save(u.x);
				}
				if (low[w] <= low[u.x]) {
					absorb(w, pu, -1);
				} else {
					absorb(w, nxt[w], -1);
					low[w] = low[u.x];
					nxt[w] = pu;
				}
			} else if (u != v && pre[w] > pre[u.x]) {
				if (pre[u.x] < low[w]) {
					absorb(w, nxt[w], -1);
					low[w] = pre[u.x];
					nxt[w] = -1;
				}
			} else if (pre[w] < pre[u.x]) {
				deg[w] -= 2;
				int c = nxt[w];
				while (c != -1 && pre[c] <= pre[u.x] && pre[u.x] < pre[c]+siz[c]) {
					c = nxt[c];
				}
				absorb(w, nxt[w], c);
				nxt[w] = c;
			}
		}
	}

	void cactus(int c, Pii pe, int d) {
		dep[c] = d;

		each(v, comps[c]) {
			each(e, G[v]) if (on[e.x] && e != pe) {
				int c2 = triNum[e.x];
				if (c2 == c) continue;

				if (dep[c2] == -1) {
					cycleStack.pb({v, e.x});
					cactus(c2, {v, e.y}, d+1);
					continue;
				}

				if (dep[c2] < dep[c]) {
					cycles.pb({ {v, e.x} });
					while (triNum[cycles.back().back().x] != c2) {
						cycles.back().pb(cycleStack.back());
						cycleStack.pop_back();
					}
					reverse(all(cycles.back()));
				}
			}
		}
	}

	void solve() {
		each(v, active) {
			on[v] = 1;
			pre[v] = -1;
		}

		cnt = 1;
		comps.clear();
		tri.clear();
		connect(active[0], {-1, -1});
		comps.emplace_back();
		save(active[0]);

		each(vec, comps) {
			tri.emplace_back();
			rep(i, 0, sz(vec)) {
				triNum[vec[i]] = sz(tri)-1;
				triPos[vec[i]] = i;
			}
		}

		each(v, active) {
			auto& vec = tri[triNum[v]];
			each(e, G[v]) {
				if (v < e.x && on[e.x] && triNum[e.x] == triNum[v]) {
					vec.pb({triPos[v], triPos[e.x], 1});
				}
			}
		}

		if (sz(comps) > 1) {
			dep.assign(sz(comps), -1);
			cycles.clear();
			cycleStack.clear();
			cactus(0, {-1, -1}, 0);

			each(vec, cycles) {
				rep(i, 0, sz(vec)) {
					int u = vec[i].y;
					int v = vec[(i+1)%sz(vec)].x;
					if (u != v) {
						auto& t = tri[triNum[u]];
						t.pb({triPos[u], triPos[v], sz(vec)});
					}
				}

				ll a = sz(vec), b = m-bridges-a;
				ans += ch2(a)*b + ch3(a);
			}
		}

		rep(i, 0, sz(tri)) {
			con4::edges = move(tri[i]);
			con4::n = sz(comps[i]);
			con4::solve();
		}

		each(v, active) {
			on[v] = 0;
		}
	}
};

namespace con2 {
	Vi pre, low, st;
	vector<Vi> comps;
	int cnt;

	void dfs(int v, Pii p) {
		pre[v] = low[v] = cnt++;
		st.pb(v);

		each(e, G[v]) if (e != p) {
			if (pre[e.x] == -1) {
				dfs(e.x, {v, e.y});
				low[v] = min(low[v], low[e.x]);
			} else {
				low[v] = min(low[v], pre[e.x]);
			}
		}

		if (low[v] == pre[v]) {
			bridges += (p.x != -1);
			comps.emplace_back();
			while (st.back() != v) {
				comps.back().pb(st.back());
				st.pop_back();
			}
			comps.back().pb(v);
			st.pop_back();
		}
	}

	void solve() {
		pre.resize(n, -1);
		low.resize(n, -1);
		con2::dfs(0, {-1, -1});
		ans += ch3(m) - ch3(m-bridges);
		con3::init();
		each(vec, comps) {
			con3::active = move(vec);
			con3::solve();
		}
	}
};

int main() {
	cin.sync_with_stdio(0); cin.tie(0);
	cout << fixed << setprecision(10);

	cin >> n >> m;
	G.resize(n);
	maxCutIters = min(20 * 300000 / m, 500);
	//deb(n, m, maxCutIters);

	rep(i, 0, m) {
		int u, v; cin >> u >> v;
		G[u-1].pb({v-1, i});
		G[v-1].pb({u-1, i});
	}

	con2::solve();
	cout << ans << endl;
	return 0;
}