#include <iostream>
#include <sstream>
#include <cmath>
#include <algorithm>
#include <utility>
#include <functional>
#include <iomanip>
#include <typeinfo>
#include <iterator>
#include <string>
#include <vector>
#include <queue>
#include <deque>
#include <tuple>
#include <map>
#include <set>
#include <numeric>
using namespace std;

#define all(container) container.begin(), container.end()
#define sortall(container) (sort(container.begin(), container.end()))
#define yn(cond) ((cond) ? (cout << "Yes" << endl) : (cout << "No" << endl))
#define YN(cond) ((cond) ? (cout << "YES" << endl) : (cout << "NO" << endl))
#define LLONG_MAX numeric_limits<long long>::max()
#define INT_MAX numeric_limits<int>::max()

typedef long long       ll;
typedef vector<int>     vi;
typedef vector<ll>      vll;
typedef vector<double>  vd;
typedef vector<bool>    vb;
typedef vector<string>  vs;
typedef vector<char>    vc;
typedef pair<int, int>  pii;
typedef pair<ll, ll>    pll;
typedef vector<pii>     vpii;
typedef vector<pll>     vpll;
typedef vector<vll>		vvll;
typedef vector<vi>		vvi;
typedef vector<vb>		vvb;
typedef vector<vs>		vvs;
typedef vector<vc>		vvc;

typedef struct edge_ {
	ll to;
	ll cost;
} edge;

typedef struct point_ {
	ll x, y;
	point_(ll x = 0, ll y = 0) : x(x), y(y) {}
} point;

template <typename T>
using mat2d = vector<vector<T>>;

constexpr double	PI = 3.14159265358979323846;
constexpr ll		INF = 1 << 15;
constexpr ll		MOD = (ll)1e9 + 7;
constexpr double	EPS = 1e-7;
constexpr int		dy4[4] = { 0, 1, 0, -1 };
constexpr int		dx4[4] = { 1, 0, -1, 0 };
constexpr int		dy8[8] = { 0, 1, 1, 1, 0, -1, -1, -1 };
constexpr int		dx8[8] = { 1, 1, 0, -1, -1, -1, 0, 1 };

template<typename T>
istream& operator >> (istream& is, vector<T>& vec) {
	for (T& x : vec) is >> x;
	return is;
}

template<typename T>
ostream& operator << (ostream& os, const vector<T>& vec) {
	for (const T& x : vec) os << x << " ";
	return os;
}

template<typename S, typename T>
istream& operator >> (istream& is, pair<S, T>& p) {
	is >> p.first >> p.second;
	return is;
}

istream& operator >> (istream& is, point& p) {
	is >> p.x >> p.y;
	return is;
}

template<typename S, typename T>
ostream& operator << (ostream& os, const pair<S, T>& p) {
	os << "{" << p.first << " " << p.second << "}";
	return os;
}

ostream& operator << (ostream& os, const edge e) {
	os << "{to: " << e.to << ", cost: " << e.cost << "}";
	return os;
}

ostream& operator << (ostream& os, const point& p) {
	os << "(" << p.x << " " << p.y << ")";
	return os;
}

/******************************************************************************/
/**********************         Don't make WA !!         **********************/
/******************************************************************************/

class Combination {
private:
	long long mod;
	vector<long long> table;
	vector<long long> invTable;

	long long mpow(long long a, long long n) {
		long long x = 1LL;
		for (; n > 0; n >>= 1, a = (a * a) % mod)
			x = (n & 1) ? (x * a) % mod : x;
		return x;
	}

	void compute(long long n) {
		table = vector<long long>(n + 1, 1);
		invTable = vector<long long>(n + 1, 1);
		for (long long i = 1LL; i < n + 1; i++) {
			table[i] = table[i - 1] * i % mod;
			invTable[i] = mpow(table[i], mod - 2);
		}
	}

public:
	Combination(long long n, long long mod = (long long)1e9 + 7) : mod(mod) { compute(n); }
	long long get(long long n, long long r) {
		if (n < r || n < 0) return 0;
		if (n == 0 && r == 0) return 1;
		return (((invTable[n - r] * invTable[r]) % mod) * table[n]) % mod;
	}
};


class UnionFind {
private:
	vector<long long> par;

public:
	UnionFind(int N) : par(N, -1) {}

	long long find(int x) {
		return par[x] < 0 ? x : par[x] = find(par[x]);
	}

	bool unite(int x, int y) {
		x = find(x);
		y = find(y);
		if (x == y) return false;
		if (par[x] > par[y]) swap(x, y);
		par[x] += par[y];
		par[y] = x;
		return true;
	}

	bool isSame(int x, int y) {
		return find(x) == find(y);
	}

	long long size(int x) {
		return -par[find(x)];
	}

};

int main()
{
	ll N, M;
	cin >> N >> M;
	vll A(M), B(M);
	for (int i = 0; i < M; i++) {
		cin >> A[i] >> B[i];
		A[i]--; B[i]--;
	}

	vll ans;
	ans.push_back(N * (N - 1) / 2);

	Combination comb(N);
	UnionFind tree(N);
	for (int i = M - 1; i >= 0; i--) {
		if (tree.isSame(A[i], B[i]))
			ans.push_back(ans[ans.size() - 1]);
		else {
			ans.push_back(ans[ans.size() - 1] - tree.size(A[i]) * tree.size(B[i]));
		}
		tree.unite(A[i], B[i]);
	}

	for (int i = ans.size() - 2; i >= 0; i--)
		cout << ans[i] << endl;

	return 0;
}

Measured memory_bytes: 6132