### BUGGY CODE ###

N, M = map(int, input().split())
bridge = []
A_B = {}
for i in range(N):
    A_B[i+1] = []

for i in range(M):
    A, B = map(int, input().split())
    bridge.append([A, B])
    A_B[A].append(B)
    A_B[B].append(A)

def depth_first(neighbor, start):
    visited = []
    stack = []
    stack.append(start)
    result = []
    while len(stack) > 0:
        next_city = stack.pop()
        if next_city in visited:
            continue
        result.append(next_city)
        visited.append(next_city)
        for nei in neighbor[next_city]:
            stack.append(nei)
    return [result]

def connected_components(neighbor):
    visited = []
    result = []
    for city in neighbor.keys():
        if city in visited:
            continue
        component = depth_first(neighbor, city)[0]
        # component = width_first(neighbor, city)[0] でも良い
        result.append(component)
        for city2 in component:
            visited.append(city2)
    return result

inconvenient = 0
for i in bridge:
    tmp3 = 1
    tmp = connected_components(A_B)
    A_B[i[0]].remove(i[1])
    A_B[i[1]].remove(i[0])
    tmp2 = connected_components(A_B)
    removes = []
    for j in tmp2:
        if j in tmp:
            removes.append(j)
    for rem in removes:
        tmp2.remove(rem)

    for k in tmp2:
        tmp3 *= len(k)
    if not tmp2 == []:
        inconvenient += tmp3
    print(inconvenient)


### FIXED CODE ###

import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

class UnionFind():
    def __init__(self, n):
        self.n = n
        # parents[i]: 要素iの親要素の番号
        # 要素iが根の場合、parents[i] = -(そのグループの要素数)
        self.parents = [-1] * n
    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]
    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)
        if x == y:
            return
        if self.parents[x] > self.parents[y]:
            x, y = y, x
        self.parents[x] += self.parents[y]
        self.parents[y] = x
    # 要素xが属するグループの要素数を返す
    def size(self, x):
        return -self.parents[self.find(x)]
    def same(self, x, y):
        return self.find(x) == self.find(y)
    # 要素xが属するグループに属する要素をリストで返す
    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]
    # 全ての根の要素をリストで返す
    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]
    # グループの数を返す
    def group_count(self):
        return len(self.roots())
    # 辞書{根の要素: [そのグループに含まれる要素のリスト], ...}を返す
    def all_group_members(self):
        return {r: self.members(r) for r in self.roots()}
    # print()での表示用
    # all_group_members()をprintする
    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

def main():
    N, M = MAP()
    AB = [LIST() for _ in range(M)]

    uf = UnionFind(N)
    ans = [N*(N-1)//2]
    for i, (A, B) in enumerate(AB[::-1]):
        if i != M-1:
            tmp = ans[-1]
            if not uf.same(A-1, B-1):
                tmp -= uf.size(A-1)*uf.size(B-1)
            ans.append(tmp)
            uf.union(A-1, B-1)

    print(*ans[::-1], sep="\n")

if __name__ == '__main__':
    main()