class UnionFind():
    def __init__(self, n):
        self.parents = [-1 for _ in range(n)]  # 各要素の親 自分が根の場合は -1 * (木の要素数)

    def root(self, x):  # xが属する木の根を返す
        if self.parents[x] < 0:  # 自分が根の場合
            return x
        else:
            self.parents[x] = self.root(self.parents[x])
            return self.parents[x]

    def merge(self, x, y):  # xが属する木とyが属する木を合体する
        x_root = self.root(x)  # xの根
        y_root = self.root(y)  # yの根

        if x_root == y_root:  # 同じ木に属する
            return

        if abs(self.parents[x_root]) >= abs(self.parents[y_root]):  # 要素数の比較
            self.parents[x_root] += self.parents[y_root]
            self.parents[y_root] = x_root
        else:
            self.parents[y_root] += self.parents[x_root]
            self.parents[x_root] = y_root

    def size(self, x):  # xが属する木の要素数
        return -self.parents[self.root(x)]

    def same(self, x, y):  # xとyが同じ木に属するか判定
        return self.root(x) == self.root(y)

    def roots(self):  # すべての根を求める
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):  # 木が何個あるか
        return len(self.roots())


def main():
    n, m = map(int, input().split())
    ab_list = [list(map(int, input().split())) for _ in range(m)]
    ans_list = [0 for _ in range(m)]
    ans_list[m - 1] = n * (n - 1) // 2
    uf = UnionFind(n)

    for i in range(m - 1, 0, -1):
        a = ab_list[i][0] - 1
        b = ab_list[i][1] - 1
        if uf.same(a, b):
            ans_list[i - 1] = ans_list[i]
        else:
            ans_list[i - 1] = ans_list[i] - \
                uf.size(uf.root(a)) * uf.size(uf.root(b))
        uf.merge(a, b)

    for ans in ans_list:
        print(ans)


if __name__ == "__main__":
    main() class UnionFind():
    def __init__(self, n):
        self.parents = [-1 for _ in range(n)]  # 各要素の親 自分が根の場合は -1 * (木の要素数)

    def root(self, x):  # xが属する木の根を返す
        if self.parents[x] < 0:  # 自分が根の場合
            return x
        else:
            self.parents[x] = self.root(self.parents[x])
            return self.parents[x]

    def merge(self, x, y):  # xが属する木とyが属する木を合体する
        x_root = self.root(x)  # xの根
        y_root = self.root(y)  # yの根

        if x_root == y_root:  # 同じ木に属する
            return

        if abs(self.parents[x_root]) >= abs(self.parents[y_root]):  # 要素数の比較
            self.parents[x_root] += self.parents[y_root]
            self.parents[y_root] = x_root
        else:
            self.parents[y_root] += self.parents[x_root]
            self.parents[x_root] = y_root

    def size(self, x):  # xが属する木の要素数
        return -self.parents[self.root(x)]

    def same(self, x, y):  # xとyが同じ木に属するか判定
        return self.root(x) == self.root(y)

    def roots(self):  # すべての根を求める
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):  # 木が何個あるか
        return len(self.roots()) UnionFind def __init__(self, n):
        self.parents = [-1 for _ in range(n)]  # 各要素の親 自分が根の場合は -1 * (木の要素数)

     __init__ -1 for _ in range(n) for _ in range(n) _ range(n) range n for _ in range(n) -1 self.parents = [-1 for _ in range(n)] self.parents self parents [-1 for _ in range(n)] self self n n def root(self, x):  # xが属する木の根を返す
        if self.parents[x] < 0:  # 自分が根の場合
            return x
        else:
            self.parents[x] = self.root(self.parents[x])
            return self.parents[x]

     root if self.parents[x] < 0:  # 自分が根の場合
            return x
        else:
            self.parents[x] = self.root(self.parents[x])
            return self.parents[x]

     self.parents[x] < 0 self.parents[x] self.parents self parents x 0 return x x self.parents[x] = self.root(self.parents[x]) self.parents[x] self.parents self parents x self.root(self.parents[x]) self.root self root self.parents[x] self.parents self parents x return self.parents[x] self.parents[x] self.parents self parents x self self x x def merge(self, x, y):  # xが属する木とyが属する木を合体する
        x_root = self.root(x)  # xの根
        y_root = self.root(y)  # yの根

        if x_root == y_root:  # 同じ木に属する
            return

        if abs(self.parents[x_root]) >= abs(self.parents[y_root]):  # 要素数の比較
            self.parents[x_root] += self.parents[y_root]
            self.parents[y_root] = x_root
        else:
            self.parents[y_root] += self.parents[x_root]
            self.parents[x_root] = y_root

     merge x_root = self.root(x) x_root self.root(x) self.root self root x y_root = self.root(y) y_root self.root(y) self.root self root y if x_root == y_root:  # 同じ木に属する
            return

         x_root == y_root x_root y_root return if abs(self.parents[x_root]) >= abs(self.parents[y_root]):  # 要素数の比較
            self.parents[x_root] += self.parents[y_root]
            self.parents[y_root] = x_root
        else:
            self.parents[y_root] += self.parents[x_root]
            self.parents[x_root] = y_root

     abs(self.parents[x_root]) >= abs(self.parents[y_root]) abs(self.parents[x_root]) abs self.parents[x_root] self.parents self parents x_root abs(self.parents[y_root]) abs self.parents[y_root] self.parents self parents y_root self.parents[x_root] += self.parents[y_root] self.parents[x_root] self.parents self parents x_root self.parents[y_root] self.parents self parents y_root self.parents[y_root] = x_root self.parents[y_root] self.parents self parents y_root x_root self.parents[y_root] += self.parents[x_root] self.parents[y_root] self.parents self parents y_root self.parents[x_root] self.parents self parents x_root self.parents[x_root] = y_root self.parents[x_root] self.parents self parents x_root y_root self self x x y y def size(self, x):  # xが属する木の要素数
        return -self.parents[self.root(x)]

     size return -self.parents[self.root(x)] -self.parents[self.root(x)] self.parents[self.root(x)] self.parents self parents self.root(x) self.root self root x self self x x def same(self, x, y):  # xとyが同じ木に属するか判定
        return self.root(x) == self.root(y)

     same return self.root(x) == self.root(y) self.root(x) == self.root(y) self.root(x) self.root self root x self.root(y) self.root self root y self self x x y y def roots(self):  # すべての根を求める
        return [i for i, x in enumerate(self.parents) if x < 0]

     roots i for i, x in enumerate(self.parents) if x < 0 for i, x in enumerate(self.parents) if x < 0 i x enumerate(self.parents) enumerate self.parents self parents x < 0 x 0 if x < 0 i return [i for i, x in enumerate(self.parents) if x < 0] [i for i, x in enumerate(self.parents) if x < 0] self self def group_count(self):  # 木が何個あるか
        return len(self.roots()) group_count return len(self.roots()) len(self.roots()) len self.roots() self.roots self roots self self def main():
    n, m = map(int, input().split())
    ab_list = [list(map(int, input().split())) for _ in range(m)]
    ans_list = [0 for _ in range(m)]
    ans_list[m - 1] = n * (n - 1) // 2
    uf = UnionFind(n)

    for i in range(m - 1, 0, -1):
        a = ab_list[i][0] - 1
        b = ab_list[i][1] - 1
        if uf.same(a, b):
            ans_list[i - 1] = ans_list[i]
        else:
            ans_list[i - 1] = ans_list[i] - \
                uf.size(uf.root(a)) * uf.size(uf.root(b))
        uf.merge(a, b)

    for ans in ans_list:
        print(ans) main n, m = map(int, input().split()) n map(int, input().split()) map int input().split() ().split () input split m list(map(int, input().split())) for _ in range(m) for _ in range(m) _ range(m) range m for _ in range(m) list(map(int, input().split())) list map(int, input().split()) map int input().split() ().split () input split ab_list = [list(map(int, input().split())) for _ in range(m)] ab_list [list(map(int, input().split())) for _ in range(m)] 0 for _ in range(m) for _ in range(m) _ range(m) range m for _ in range(m) 0 ans_list = [0 for _ in range(m)] ans_list [0 for _ in range(m)] ans_list[m - 1] = n * (n - 1) // 2 ans_list[m - 1] ans_list m - 1 m 1 n * (n - 1) // 2 n * (n - 1) n n - 1 n 1 2 uf = UnionFind(n) uf UnionFind(n) UnionFind n for i in range(m - 1, 0, -1):
        a = ab_list[i][0] - 1
        b = ab_list[i][1] - 1
        if uf.same(a, b):
            ans_list[i - 1] = ans_list[i]
        else:
            ans_list[i - 1] = ans_list[i] - \
                uf.size(uf.root(a)) * uf.size(uf.root(b))
        uf.merge(a, b)

     i range(m - 1, 0, -1) range m - 1 m 1 0 -1 a = ab_list[i][0] - 1 a ab_list[i][0] - 1 ab_list[i][0] [i] ab_list i 0 1 b = ab_list[i][1] - 1 b ab_list[i][1] - 1 ab_list[i][1] [i] ab_list i 1 1 if uf.same(a, b):
            ans_list[i - 1] = ans_list[i]
        else:
            ans_list[i - 1] = ans_list[i] - \
                uf.size(uf.root(a)) * uf.size(uf.root(b))
         uf.same(a, b) uf.same uf same a b ans_list[i - 1] = ans_list[i] ans_list[i - 1] ans_list i - 1 i 1 ans_list[i] ans_list i ans_list[i - 1] = ans_list[i] - \
                uf.size(uf.root(a)) * uf.size(uf.root(b)) ans_list[i - 1] ans_list i - 1 i 1 ans_list[i] - \
                uf.size(uf.root(a)) * uf.size(uf.root(b)) ans_list[i] ans_list i uf.size(uf.root(a)) * uf.size(uf.root(b)) uf.size(uf.root(a)) uf.size uf size uf.root(a) uf.root uf root a uf.size(uf.root(b)) uf.size uf size uf.root(b) uf.root uf root b uf.merge(a, b) uf.merge uf merge a b for ans in ans_list:
        print(ans) ans ans_list print(ans) print ans if __name__ == "__main__":
    main() __name__ == "__main__" __name__ "__main__" main() main class UnionFind():
    def __init__(self, n):
        self.parents = [-1 for _ in range(n)]  # 各要素の親 自分が根の場合は -1 * (木の要素数)

    def root(self, x):  # xが属する木の根を返す
        if self.parents[x] < 0:  # 自分が根の場合
            return x
        else:
            self.parents[x] = self.root(self.parents[x])
            return self.parents[x]

    def merge(self, x, y):  # xが属する木とyが属する木を合体する
        x_root = self.root(x)  # xの根
        y_root = self.root(y)  # yの根

        if x_root == y_root:  # 同じ木に属する
            return

        if abs(self.parents[x_root]) >= abs(self.parents[y_root]):  # 要素数の比較
            self.parents[x_root] += self.parents[y_root]
            self.parents[y_root] = x_root
        else:
            self.parents[y_root] += self.parents[x_root]
            self.parents[x_root] = y_root

    def size(self, x):  # xが属する木の要素数
        return -self.parents[self.root(x)]

    def same(self, x, y):  # xとyが同じ木に属するか判定
        return self.root(x) == self.root(y)

    def roots(self):  # すべての根を求める
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):  # 木が何個あるか
        return len(self.roots()) class UnionFind():
    def __init__(self, n):
        self.parents = [-1 for _ in range(n)]  # 各要素の親 自分が根の場合は -1 * (木の要素数)

    def root(self, x):  # xが属する木の根を返す
        if self.parents[x] < 0:  # 自分が根の場合
            return x
        else:
            self.parents[x] = self.root(self.parents[x])
            return self.parents[x]

    def merge(self, x, y):  # xが属する木とyが属する木を合体する
        x_root = self.root(x)  # xの根
        y_root = self.root(y)  # yの根

        if x_root == y_root:  # 同じ木に属する
            return

        if abs(self.parents[x_root]) >= abs(self.parents[y_root]):  # 要素数の比較
            self.parents[x_root] += self.parents[y_root]
            self.parents[y_root] = x_root
        else:
            self.parents[y_root] += self.parents[x_root]
            self.parents[x_root] = y_root

    def size(self, x):  # xが属する木の要素数
        return -self.parents[self.root(x)]

    def same(self, x, y):  # xとyが同じ木に属するか判定
        return self.root(x) == self.root(y)

    def roots(self):  # すべての根を求める
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):  # 木が何個あるか
        return len(self.roots()) UnionFind def main():
    n, m = map(int, input().split())
    ab_list = [list(map(int, input().split())) for _ in range(m)]
    ans_list = [0 for _ in range(m)]
    ans_list[m - 1] = n * (n - 1) // 2
    uf = UnionFind(n)

    for i in range(m - 1, 0, -1):
        a = ab_list[i][0] - 1
        b = ab_list[i][1] - 1
        if uf.same(a, b):
            ans_list[i - 1] = ans_list[i]
        else:
            ans_list[i - 1] = ans_list[i] - \
                uf.size(uf.root(a)) * uf.size(uf.root(b))
        uf.merge(a, b)

    for ans in ans_list:
        print(ans) def main():
    n, m = map(int, input().split())
    ab_list = [list(map(int, input().split())) for _ in range(m)]
    ans_list = [0 for _ in range(m)]
    ans_list[m - 1] = n * (n - 1) // 2
    uf = UnionFind(n)

    for i in range(m - 1, 0, -1):
        a = ab_list[i][0] - 1
        b = ab_list[i][1] - 1
        if uf.same(a, b):
            ans_list[i - 1] = ans_list[i]
        else:
            ans_list[i - 1] = ans_list[i] - \
                uf.size(uf.root(a)) * uf.size(uf.root(b))
        uf.merge(a, b)

    for ans in ans_list:
        print(ans) main
class UnionFind():
    def __init__(self, n):
        self.parents = [-1 for _ in range(n)]  # 各要素の親 自分が根の場合は -1 * (木の要素数)

    def root(self, x):  # xが属する木の根を返す
        if self.parents[x] < 0:  # 自分が根の場合
            return x
        else:
            self.parents[x] = self.root(self.parents[x])
            return self.parents[x]

    def merge(self, x, y):  # xが属する木とyが属する木を合体する
        x_root = self.root(x)  # xの根
        y_root = self.root(y)  # yの根

        if x_root == y_root:  # 同じ木に属する
            return

        if abs(self.parents[x_root]) >= abs(self.parents[y_root]):  # 要素数の比較
            self.parents[x_root] += self.parents[y_root]
            self.parents[y_root] = x_root
        else:
            self.parents[y_root] += self.parents[x_root]
            self.parents[x_root] = y_root

    def size(self, x):  # xが属する木の要素数
        return -self.parents[self.root(x)]

    def same(self, x, y):  # xとyが同じ木に属するか判定
        return self.root(x) == self.root(y)

    def roots(self):  # すべての根を求める
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):  # 木が何個あるか
        return len(self.roots())


def main():
    n, m = map(int, input().split())
    ab_list = [list(map(int, input().split())) for _ in range(m)]
    ans_list = [0 for _ in range(m)]
    ans_list[m - 1] = n * (n - 1) // 2
    uf = UnionFind(n)

    for i in range(m - 1, 0, -1):
        a = ab_list[i][0] - 1
        b = ab_list[i][1] - 1
        if uf.same(a, b):
            ans_list[i - 1] = ans_list[i]
        else:
            ans_list[i - 1] = ans_list[i] - \
                uf.size(uf.root(a)) * uf.size(uf.root(b))
        uf.merge(a, b)

    for ans in ans_list:
        print(ans)


if __name__ == "__main__":
    main()
