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

typedef long long ll;

struct DSU {
    vector<int> f, size;
    DSU() {}
    DSU(int n) : f(n) {
        iota(f.begin(), f.end(), 0);
        size.assign(n, 1);
    }
    int find(int x) {
        while (x != f[x]) x = f[x] = f[f[x]];
        return x;
    }

    void merge(int x, int y) {
        x = find(x);
        y = find(y);
        if (x == y) return;
        if (size[x] < size[y]) swap(x, y);
        f[y] = x;
        size[x] += size[y];
    }
};

struct Graph {
    vector<vector<int> > adj;
    vector<int> idx, low, color;
    vector<bool> in_stack;

    Graph() {}
    Graph(int n) {
        init(n);
    }

    void init(int n) {
        adj.assign(n, vector<int>());
        idx.assign(n, 0);
        low.assign(n, 0);
        in_stack.assign(n, false);
        color.assign(n, -1);
    }

    void add_edge(int u, int v) {
        adj[u].push_back(v);
    }

    void dfs(int u);

    bool vis(int u) {
        return idx[u] > 0;
    }
};

void Graph::dfs(int u) {
    static int tot = 0;
    static stack<int> st;
    idx[u] = low[u] = ++tot;
    st.push(u);
    in_stack[u] = true;
    for (int v : adj[u]) {
        if (idx[v] == 0) {
            dfs(v);
            low[u] = min(low[u], low[v]);
        } else if (in_stack[v]) {
            low[u] = min(low[u], idx[v]);
        }
    }
    if (idx[u] == low[u]) {
        int v;
        static int clr = 0;
        do {
            v = st.top();
            st.pop();
            in_stack[v] = false;
            color[v] = clr;
        } while (v != u);
        ++clr;
    }
}

int main() {
    ios::sync_with_stdio(0);
    int n, m;
    cin >> n >> m;
    DSU dsu(n);
    vector<pair<int, int> > edges;
    for (int i = 0, u, v; i < m; i++) {
        cin >> u >> v;
        --u;
        --v;
        edges.push_back({u, v});
    }
    ll ans = 0;
    auto solve = [&](auto &&self, int l, int r, vector<int> E) -> void {
        // if (l == r) {
        //     cout << "###### Time: " << l << "\n";
        //     for (int i : E) {
        //         auto [x, y] = edges[i];
        //         cout << x << ' ' << y << '\n';
        //     }
        // }
        unordered_map<int, int> mp;
        int N = 0;
        for (int i : E) {
            if (i > r) continue;
            auto [x, y] = edges[i];
            x = dsu.find(x);
            y = dsu.find(y);
            if (x == y) continue;
            if (!mp.count(x)) mp[x] = N++;
            if (!mp.count(y)) mp[y] = N++;
        }
        Graph g(N);
        for (int i : E) {
            if (i > r) continue;
            auto [x, y] = edges[i];
            x = dsu.find(x);
            y = dsu.find(y);
            if (x == y) continue;
            g.add_edge(mp[x], mp[y]);
        }
        for (int i = 0; i < N; i++) {
            if (!g.vis(i)) g.dfs(i);
        }
        vector<int> nE;
        for (int i : E) {
            if (i > r) continue;
            auto [x, y] = edges[i];
            x = dsu.find(x);
            y = dsu.find(y);
            if (x == y) continue;
            if (g.color[mp[x]] == g.color[mp[y]]) {
                // nE 这个边集令 (x,y) 在 [l,r] 内连通
                nE.push_back(i);
            }
        }
        if (l == r) {
            for (int i : nE) {
                auto [x, y] = edges[i];
                x = dsu.find(x);
                y = dsu.find(y);
                if (x == y) continue;
                // i 这条边对答案的贡献: 令 size(x) * size(y) 个 pairs 连通
                ans += 1ll * dsu.size[x] * dsu.size[y];
                dsu.merge(x, y);
            }
            cout << ans << '\n';
            return;
        }
        int mid = (l + r) >> 1;
        self(self, l, mid, nE);
        self(self, mid + 1, r, nE);
    };
    vector<int> E(m);
    iota(E.begin(), E.end(), 0);
    solve(solve, 0, m - 1, E);
    return 0;
}