class UnionFind_size:

    def __init__(self, n):

        self.par = [i for i in range(n+1)]

        self.size = [1] * (n+1)

    

    # 根を検索する関数

    def find(self, x):

        if self.par[x] == x:

            return x

        else:

            self.par[x] = self.find(self.par[x])

            return self.find(self.par[x])

  

    # 結合(unite)する関数

    def unite(self, x, y):

        x = self.find(x)

        y = self.find(y)

        if x == y:

            return

        if self.size[x] < self.size[y]:

            self.par[x] = y

            self.size[y] += self.size[x]

        else:

            self.par[y] = x

            self.size[x] += self.size[y]

           

    # 同じグループに属するかを判定する関数

    def same_check(self, x, y):

        return self.find(x) == self.find(y)

    

    # 要素が属する木のサイズを返す関数

    def get_size(self, x):

        return self.size[self.find(x)]

    

    # グループ数を返す関数

    def group_sum(self):

        c = 0

        for i in range(len(self.par)):

            if self.find(i) == i:

                c += 1

        return c





if __name__ == "__main__":

    N,M = list(map(int, input().split()))

    uf = UnionFind_size(N)



    A, B = [0] * M, [0] * M

    for i in range(M):

        A[i], B[i] = [int(j) for j in input().split()]



    total = int(N * (N-1) / 2)

    ans = [total]

    for i in range(M-1):

        if uf.same_check(A[-(i+1)], B[-(i+1)]):

            ans.append(ans[i])

        else:

            ans.append(ans[i] - uf.get_size(A[-(i+1)]) * uf.get_size(B[-(i+1)]))

        uf.unite(A[-(i+1)], B[-(i+1)])

    

    for i in (reversed(ans)):

        print(i)
import sys

read = sys.stdin.read

readline = sys.stdin.readline

readlines = sys.stdin.readlines



class UnionFind:

    def __init__(self, n):

        # 初期状態は全要素が根なので、親は自分自身

        self.par = [i for i in range(n+1)]

        # 集団の要素数(size)を格納する(初期は全て1)

        self.size = [1] * (n+1)

    

    # 根を検索する関数

    def find(self, x):

        # 根までたどったらその番号を返す

        if self.par[x] == x:

            return x

        # 根でないなら親の要素で再検索

        else:

            # 検索過程で親を書き換える(圧縮経路)

            self.par[x] = self.find(self.par[x])

            return self.find(self.par[x])

  

    # 結合(unite)する関数

    def unite(self, x, y):

        # 根を探す

        x = self.find(x)

        y = self.find(y)

        if x == y:

            return

        # サイズを比較し、小さい方を大きい方に繋げる

        if self.size[x] < self.size[y]:

            self.par[x] = y

            self.size[y] += self.size[x]

        else:

            self.par[y] = x

            self.size[x] += self.size[y]

           

    # 同じグループに属するかを判定する関数

    def is_same(self, x, y):

        return self.find(x) == self.find(y)

    

    # 要素が属する木のサイズを返す関数

    def get_size(self, x):

        return self.size[self.find(x)]

    

    # グループ数を返す関数

    def group_sum(self):

        c = 0

        for i in range(len(self.par)):

            if self.find(i) == i:

                c += 1

        return c

    



def main():

    N,M,*ab = list(map(int, read().split()))

    

    E = [(a, b) for a, b in zip(*[iter(ab)]*2)]



    pair = N * (N - 1) // 2

    ans = []



    uf = UnionFind(N)

    con = 0

    for a, b in reversed(E):

        ans.append(pair)

        if not uf.is_same(a, b):

            n_a = uf.get_size(a)

            n_b = uf.get_size(b)

            pair -= n_a * n_b



        uf.unite(a, b)



    print(("\n".join(map(str, ans[::-1]))))





if __name__ == "__main__":

    main()

class UnionFind_size:
    def __init__(self, n):
        self.par = [i for i in range(n + 1)]
        self.size = [1] * (n + 1)

    # 根を検索する関数
    def find(self, x):
        if self.par[x] == x:
            return x
        else:
            self.par[x] = self.find(self.par[x])
            return self.find(self.par[x])

    # 結合(unite)する関数
    def unite(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if x == y:
            return
        if self.size[x] < self.size[y]:
            self.par[x] = y
            self.size[y] += self.size[x]
        else:
            self.par[y] = x
            self.size[x] += self.size[y]

    # 同じグループに属するかを判定する関数
    def same_check(self, x, y):
        return self.find(x) == self.find(y)

    # 要素が属する木のサイズを返す関数
    def get_size(self, x):
        return self.size[self.find(x)]

    # グループ数を返す関数
    def group_sum(self):
        c = 0
        for i in range(len(self.par)):
            if self.find(i) == i:
                c += 1
        return c


if __name__ == "__main__":
    N, M = list(map(int, input().split()))
    uf = UnionFind_size(N)
    A, B = [0] * M, [0] * M
    for i in range(M):
        A[i], B[i] = [int(j) for j in input().split()]
    total = int(N * (N - 1) / 2)
    ans = [total]
    for i in range(M - 1):
        if uf.same_check(A[-(i + 1)], B[-(i + 1)]):
            ans.append(ans[i])
        else:
            ans.append(ans[i] - uf.get_size(A[-(i + 1)]) * uf.get_size(B[-(i + 1)]))
        uf.unite(A[-(i + 1)], B[-(i + 1)])
    for i in reversed(ans):
        print(i)

import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines


class UnionFind:
    def __init__(self, n):
        # 初期状態は全要素が根なので、親は自分自身
        self.par = [i for i in range(n + 1)]
        # 集団の要素数(size)を格納する(初期は全て1)
        self.size = [1] * (n + 1)

    # 根を検索する関数
    def find(self, x):
        # 根までたどったらその番号を返す
        if self.par[x] == x:
            return x
        # 根でないなら親の要素で再検索
        else:
            # 検索過程で親を書き換える(圧縮経路)
            self.par[x] = self.find(self.par[x])
            return self.find(self.par[x])

    # 結合(unite)する関数
    def unite(self, x, y):
        # 根を探す
        x = self.find(x)
        y = self.find(y)
        if x == y:
            return
        # サイズを比較し、小さい方を大きい方に繋げる
        if self.size[x] < self.size[y]:
            self.par[x] = y
            self.size[y] += self.size[x]
        else:
            self.par[y] = x
            self.size[x] += self.size[y]

    # 同じグループに属するかを判定する関数
    def is_same(self, x, y):
        return self.find(x) == self.find(y)

    # 要素が属する木のサイズを返す関数
    def get_size(self, x):
        return self.size[self.find(x)]

    # グループ数を返す関数
    def group_sum(self):
        c = 0
        for i in range(len(self.par)):
            if self.find(i) == i:
                c += 1
        return c


def main():
    N, M, *ab = list(map(int, read().split()))
    E = [(a, b) for a, b in zip(*[iter(ab)] * 2)]
    pair = N * (N - 1) // 2
    ans = []
    uf = UnionFind(N)
    con = 0
    for a, b in reversed(E):
        ans.append(pair)
        if not uf.is_same(a, b):
            n_a = uf.get_size(a)
            n_b = uf.get_size(b)
            pair -= n_a * n_b
        uf.unite(a, b)
    print(("\n".join(map(str, ans[::-1]))))


if __name__ == "__main__":
    main()

-class UnionFind_size: +import sys + +read = sys.stdin.read +readline = sys.stdin.readline +readlines = sys.stdin.readlines + + +class UnionFind: +        # 初期状態は全要素が根なので、親は自分自身 +        # 集団の要素数(size)を格納する(初期は全て1) +        # 根までたどったらその番号を返す +        # 根でないなら親の要素で再検索 +            # 検索過程で親を書き換える(圧縮経路) +        # 根を探す +        # サイズを比較し、小さい方を大きい方に繋げる -    def same_check(self, x, y): +    def is_same(self, x, y): +def main(): +    N, M, *ab = list(map(int, read().split())) +    E = [(a, b) for a, b in zip(*[iter(ab)] * 2)] +    pair = N * (N - 1) // 2 +    ans = [] +    uf = UnionFind(N) +    con = 0 +    for a, b in reversed(E): +        ans.append(pair) +        if not uf.is_same(a, b): +            n_a = uf.get_size(a) +            n_b = uf.get_size(b) +            pair -= n_a * n_b +        uf.unite(a, b) +    print(("\n".join(map(str, ans[::-1])))) + + -    N, M = list(map(int, input().split())) -    uf = UnionFind_size(N) -    A, B = [0] * M, [0] * M -    for i in range(M): -        A[i], B[i] = [int(j) for j in input().split()] -    total = int(N * (N - 1) / 2) -    ans = [total] -    for i in range(M - 1): -        if uf.same_check(A[-(i + 1)], B[-(i + 1)]): -            ans.append(ans[i]) -        else: -            ans.append(ans[i] - uf.get_size(A[-(i + 1)]) * uf.get_size(B[-(i + 1)])) -        uf.unite(A[-(i + 1)], B[-(i + 1)]) -    for i in reversed(ans): -        print(i) +    main()