#include <bits/stdc++.h>

using namespace std;
using ll = long long;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, m;
    cin >> n >> m;

    vector<set<pair<int, int>>> in(n), out(n);
    vector<int> fa(n), sz(n, 1);
    iota(fa.begin(), fa.end(), 0);

    auto leader = [&](int x) {
        while (fa[x] != x) {
            x = fa[x] = fa[fa[x]];
        }
        return x;
    };

    ll ans = 0;

    auto unite = [&](auto self, int x, int y) -> void {
        x = leader(x), y = leader(y);
        if (x == y) {
            return;
        }

        if (in[x].size() + out[x].size() < in[y].size() + out[y].size()) {
            swap(x, y);
        }

        fa[y] = x;

        for (auto [p, v] : in[y]) {
            out[p].extract({y, v});
            ans -= sz[y];
            assert(p == leader(p));
            if (p != x && !in[x].count({p, v})) {
                out[p].insert({x, v});
                ans += sz[x];
                in[x].insert({p, v});
            }
        }

        for (auto [p, v] : out[y]) {
            in[p].extract({y, v});
            ans -= sz[p];
            assert(p == leader(p));
            if (p != x && !out[x].count({p, v})) {
                in[p].insert({x, v});
                ans += sz[p];
                out[x].insert({p, v});
            }
        }

        ans -= 1LL * sz[x] * (sz[x] - 1) + 1LL * sz[y] * (sz[y] - 1);
        sz[x] += sz[y];
        ans += in[x].size() * 1LL * sz[y];
        ans += 1LL * sz[x] * (sz[x] - 1);

        for (auto [p, v] : in[y]) {
            auto it = out[x].lower_bound({p, -1});
            if (p != x && it != out[x].end() && it->first == p) {
                self(self, p, y);
            }
        }

//        for (auto [p, xt] : in[x]) {
//            assert(leader(p) == p);
//            assert(p != x);
//        }
    };

    for (int i = 0; i < m; ++i) {
        int a, b;
        cin >> a >> b;
        a -= 1, b -= 1;
        int la = leader(a), lb = leader(b);

        if (la != lb) {
            auto it = in[la].lower_bound({lb, 0});
            if (it != in[la].end() && it->first == lb) {
                unite(unite, la, lb);
            } else {
                if (!in[lb].count({la, a})) {
                    ans += sz[lb];
                    in[lb].insert({la, a});
                    out[la].insert({lb, a});
                }
            }
        }

        cout << ans << '\n';
    }

    return 0;
}