# 辺を消していく操作は難しい
# 操作を逆から考え、辺を足していくと考える
#####################


class UnionFind:

    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, v):  # vが属する集合の根を返す
        if self.parents[v] < 0:
            return v
        else:
            self.parents[v] = self.find(self.parents[v])
            return self.parents[v]

    def unite(self, u, v):  # 「uが属する集合」と「vが属する集合」を併合（根同士を結ぶ）
        u = self.find(u)
        v = self.find(v)

        if u == v:
            return

        if self.parents[u] > self.parents[v]:  # u < v に統一する
            u, v = v, u

        self.parents[u] += self.parents[v]
        self.parents[v] = u

    def size(self, v):  # vが属する集合の要素数
        return -self.parents[self.find(v)]

    def same(self, u, v):  # uとvが同じ集合に属するか否か
        return self.find(u) == self.find(v)
############################################
N, M = map(int, input().split())
uf = UnionFind(N)
edges = []

for i in range(M):
    A, B = map(int, input().split())
    # 0-indexに直す
    edges.append((A - 1, B - 1))

# n_C_2 = N*(N-1)//2
# [辺が(M-1)本(=1本崩落), ..., 辺が1本(=M-1本崩落), 辺が0本(=M本崩落)]
# [-1]はn_C_2のまま、[-2]から[-M]に向かって逆順に更新していく（辺を増やしていく）

total = [N * (N - 1) // 2 for _ in range(M)]

# -i-1 = -1,-2,...,-(M-1)
# -i-2 = -2,-3,...,-M
for i in range(M - 1):
    u, v = edges[-i - 1]
    # 既に同じ集合に属しているなら、辺を足しても、行き来出来ない組み合わせ数は変わらない（減らない）
    if uf.same(u, v):
        total[-i - 2] = total[-i - 1]
    # uとvが異なる集合に属している場合
    # 辺を張ることで、ダメな組み合わせが(uの要素数)*(vの要素数)だけ減る　（行き来できるようになる）
    else:
        total[-i - 2] = total[-i - 1] - uf.size(u) * uf.size(v)
        uf.unite(u, v)

for t in total:
    print(t) class UnionFind:

    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, v):  # vが属する集合の根を返す
        if self.parents[v] < 0:
            return v
        else:
            self.parents[v] = self.find(self.parents[v])
            return self.parents[v]

    def unite(self, u, v):  # 「uが属する集合」と「vが属する集合」を併合（根同士を結ぶ）
        u = self.find(u)
        v = self.find(v)

        if u == v:
            return

        if self.parents[u] > self.parents[v]:  # u < v に統一する
            u, v = v, u

        self.parents[u] += self.parents[v]
        self.parents[v] = u

    def size(self, v):  # vが属する集合の要素数
        return -self.parents[self.find(v)]

    def same(self, u, v):  # uとvが同じ集合に属するか否か
        return self.find(u) == self.find(v)
############################################ UnionFind def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

     __init__ self.n = n self.n self n n self.parents = [-1] * n self.parents self parents [-1] * n [-1] -1 n self self n n def find(self, v):  # vが属する集合の根を返す
        if self.parents[v] < 0:
            return v
        else:
            self.parents[v] = self.find(self.parents[v])
            return self.parents[v]

     find if self.parents[v] < 0:
            return v
        else:
            self.parents[v] = self.find(self.parents[v])
            return self.parents[v]

     self.parents[v] < 0 self.parents[v] self.parents self parents v 0 return v v self.parents[v] = self.find(self.parents[v]) self.parents[v] self.parents self parents v self.find(self.parents[v]) self.find self find self.parents[v] self.parents self parents v return self.parents[v] self.parents[v] self.parents self parents v self self v v def unite(self, u, v):  # 「uが属する集合」と「vが属する集合」を併合（根同士を結ぶ）
        u = self.find(u)
        v = self.find(v)

        if u == v:
            return

        if self.parents[u] > self.parents[v]:  # u < v に統一する
            u, v = v, u

        self.parents[u] += self.parents[v]
        self.parents[v] = u

     unite u = self.find(u) u self.find(u) self.find self find u v = self.find(v) v self.find(v) self.find self find v if u == v:
            return

         u == v u v return if self.parents[u] > self.parents[v]:  # u < v に統一する
            u, v = v, u

         self.parents[u] > self.parents[v] self.parents[u] self.parents self parents u self.parents[v] self.parents self parents v u, v = v, u u v v u self.parents[u] += self.parents[v] self.parents[u] self.parents self parents u self.parents[v] self.parents self parents v self.parents[v] = u self.parents[v] self.parents self parents v u self self u u v v def size(self, v):  # vが属する集合の要素数
        return -self.parents[self.find(v)]

     size return -self.parents[self.find(v)] -self.parents[self.find(v)] self.parents[self.find(v)] self.parents self parents self.find(v) self.find self find v self self v v def same(self, u, v):  # uとvが同じ集合に属するか否か
        return self.find(u) == self.find(v)
############################################ same return self.find(u) == self.find(v) self.find(u) == self.find(v) self.find(u) self.find self find u self.find(v) self.find self find v self self u u v v N, M = map(int, input().split()) N map(int, input().split()) map int input().split() ().split () input split M uf = UnionFind(N) uf UnionFind(N) UnionFind N edges = [] edges [] for i in range(M):
    A, B = map(int, input().split())
    # 0-indexに直す
    edges.append((A - 1, B - 1))

# n_C_2 = N*(N-1)//2
# [辺が(M-1)本(=1本崩落), ..., 辺が1本(=M-1本崩落), 辺が0本(=M本崩落)]
# [-1]はn_C_2のまま、[-2]から[-M]に向かって逆順に更新していく（辺を増やしていく） i range(M) range M A, B = map(int, input().split()) A map(int, input().split()) map int input().split() ().split () input split B edges.append((A - 1, B - 1)) edges.append edges append (A - 1, B - 1) A - 1 A 1 B - 1 B 1 N * (N - 1) // 2 for _ in range(M) for _ in range(M) _ range(M) range M for _ in range(M) N * (N - 1) // 2 N * (N - 1) N N - 1 N 1 2 total = [N * (N - 1) // 2 for _ in range(M)] total [N * (N - 1) // 2 for _ in range(M)] for i in range(M - 1):
    u, v = edges[-i - 1]
    # 既に同じ集合に属しているなら、辺を足しても、行き来出来ない組み合わせ数は変わらない（減らない）
    if uf.same(u, v):
        total[-i - 2] = total[-i - 1]
    # uとvが異なる集合に属している場合
    # 辺を張ることで、ダメな組み合わせが(uの要素数)*(vの要素数)だけ減る　（行き来できるようになる）
    else:
        total[-i - 2] = total[-i - 1] - uf.size(u) * uf.size(v)
        uf.unite(u, v) i range(M - 1) range M - 1 M 1 u, v = edges[-i - 1] u edges[-i - 1] edges -i - 1 -i i 1 v if uf.same(u, v):
        total[-i - 2] = total[-i - 1]
    # uとvが異なる集合に属している場合
    # 辺を張ることで、ダメな組み合わせが(uの要素数)*(vの要素数)だけ減る　（行き来できるようになる）
    else:
        total[-i - 2] = total[-i - 1] - uf.size(u) * uf.size(v)
        uf.unite(u, v) uf.same(u, v) uf.same uf same u v total[-i - 2] = total[-i - 1] total[-i - 2] total -i - 2 -i i 2 total[-i - 1] total -i - 1 -i i 1 total[-i - 2] = total[-i - 1] - uf.size(u) * uf.size(v) total[-i - 2] total -i - 2 -i i 2 total[-i - 1] - uf.size(u) * uf.size(v) total[-i - 1] total -i - 1 -i i 1 uf.size(u) * uf.size(v) uf.size(u) uf.size uf size u uf.size(v) uf.size uf size v uf.unite(u, v) uf.unite uf unite u v for t in total:
    print(t) t total print(t) print t B = map(int, input().split()) map(int, input().split()) B M = map(int, input().split()) map(int, input().split()) M uf = UnionFind(N) UnionFind(N) uf A, B = map(int, input().split()) map(int, input().split()) A N, M = map(int, input().split()) map(int, input().split()) N edges = [] [] edges v = edges[-i - 1] edges[-i - 1] v class UnionFind:

    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, v):  # vが属する集合の根を返す
        if self.parents[v] < 0:
            return v
        else:
            self.parents[v] = self.find(self.parents[v])
            return self.parents[v]

    def unite(self, u, v):  # 「uが属する集合」と「vが属する集合」を併合（根同士を結ぶ）
        u = self.find(u)
        v = self.find(v)

        if u == v:
            return

        if self.parents[u] > self.parents[v]:  # u < v に統一する
            u, v = v, u

        self.parents[u] += self.parents[v]
        self.parents[v] = u

    def size(self, v):  # vが属する集合の要素数
        return -self.parents[self.find(v)]

    def same(self, u, v):  # uとvが同じ集合に属するか否か
        return self.find(u) == self.find(v)
############################################ class UnionFind:

    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, v):  # vが属する集合の根を返す
        if self.parents[v] < 0:
            return v
        else:
            self.parents[v] = self.find(self.parents[v])
            return self.parents[v]

    def unite(self, u, v):  # 「uが属する集合」と「vが属する集合」を併合（根同士を結ぶ）
        u = self.find(u)
        v = self.find(v)

        if u == v:
            return

        if self.parents[u] > self.parents[v]:  # u < v に統一する
            u, v = v, u

        self.parents[u] += self.parents[v]
        self.parents[v] = u

    def size(self, v):  # vが属する集合の要素数
        return -self.parents[self.find(v)]

    def same(self, u, v):  # uとvが同じ集合に属するか否か
        return self.find(u) == self.find(v)
############################################ UnionFind total = [N * (N - 1) // 2 for _ in range(M)] [N * (N - 1) // 2 for _ in range(M)] total u, v = edges[-i - 1] edges[-i - 1] u
# 辺を消していく操作は難しい
# 操作を逆から考え、辺を足していくと考える
#####################


class UnionFind:

    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, v):  # vが属する集合の根を返す
        if self.parents[v] < 0:
            return v
        else:
            self.parents[v] = self.find(self.parents[v])
            return self.parents[v]

    def unite(self, u, v):  # 「uが属する集合」と「vが属する集合」を併合（根同士を結ぶ）
        u = self.find(u)
        v = self.find(v)

        if u == v:
            return

        if self.parents[u] > self.parents[v]:  # u < v に統一する
            u, v = v, u

        self.parents[u] += self.parents[v]
        self.parents[v] = u

    def size(self, v):  # vが属する集合の要素数
        return -self.parents[self.find(v)]

    def same(self, u, v):  # uとvが同じ集合に属するか否か
        return self.find(u) == self.find(v)
############################################
N, M = map(int, input().split())
uf = UnionFind(N)
edges = []

for i in range(M):
    A, B = map(int, input().split())
    # 0-indexに直す
    edges.append((A - 1, B - 1))

# n_C_2 = N*(N-1)//2
# [辺が(M-1)本(=1本崩落), ..., 辺が1本(=M-1本崩落), 辺が0本(=M本崩落)]
# [-1]はn_C_2のまま、[-2]から[-M]に向かって逆順に更新していく（辺を増やしていく）

total = [N * (N - 1) // 2 for _ in range(M)]

# -i-1 = -1,-2,...,-(M-1)
# -i-2 = -2,-3,...,-M
for i in range(M - 1):
    u, v = edges[-i - 1]
    # 既に同じ集合に属しているなら、辺を足しても、行き来出来ない組み合わせ数は変わらない（減らない）
    if uf.same(u, v):
        total[-i - 2] = total[-i - 1]
    # uとvが異なる集合に属している場合
    # 辺を張ることで、ダメな組み合わせが(uの要素数)*(vの要素数)だけ減る　（行き来できるようになる）
    else:
        total[-i - 2] = total[-i - 1] - uf.size(u) * uf.size(v)
        uf.unite(u, v)

for t in total:
    print(t)
