import sys
import heapq
import math
import fractions
import bisect
import itertools
from collections import Counter
from collections import deque
from operator import itemgetter
def input(): return sys.stdin.readline().strip()
def mp(): return map(int,input().split())
def lmp(): return list(map(int,input().split()))


class UnionFind():
    def __init__(self, n):
        self.n = n
        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

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    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()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

n,m=mp()
l=[]
for i in range(m):
    l.append(lmp())
ans=[0]*m    
ans[m-1]=n*(n-1)//2
uf=UnionFind(n+1)
for i in range(m-1):
    if not uf.same(l[m-1-i][0],l[m-1-i][1]):
        ans[m-2-i]=ans[m-i-1]-uf.size(l[m-1-i][0])*uf.size(l[m-1-i][1])
        uf.union(l[m-1-i][0],l[m-1-i][1])
    else:
        ans[m-2-i]=ans[m-i-1]
for a in ans:
    print(a)     import sys sys import heapq heapq import math math import fractions fractions import bisect bisect import itertools itertools from collections import Counter from collections import deque from operator import itemgetter def input(): return sys.stdin.readline().strip() input def mp(): return map(int,input().split()) mp def lmp(): return list(map(int,input().split())) lmp class UnionFind():
    def __init__(self, n):
        self.n = n
        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

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    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()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots()) 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, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

     find if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(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.find(self.parents[x]) self.parents[x] self.parents self parents x self.find(self.parents[x]) self.find self find 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 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

     union x = self.find(x) x self.find(x) self.find self find x y = self.find(y) y self.find(y) self.find self find y if x == y:
            return

         x == y x y return if self.parents[x] > self.parents[y]:
            x, y = y, x

         self.parents[x] > self.parents[y] self.parents[x] self.parents self parents x self.parents[y] self.parents self parents y x, y = y, x x y y x self.parents[x] += self.parents[y] self.parents[x] self.parents self parents x self.parents[y] self.parents self parents y self.parents[y] = x self.parents[y] self.parents self parents y x self self x x y y def size(self, x):
        return -self.parents[self.find(x)]

     size return -self.parents[self.find(x)] -self.parents[self.find(x)] self.parents[self.find(x)] self.parents self parents self.find(x) self.find self find x self self x x def same(self, x, y):
        return self.find(x) == self.find(y)

     same return self.find(x) == self.find(y) self.find(x) == self.find(y) self.find(x) self.find self find x self.find(y) self.find self find y self self x x y y def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

     members root = self.find(x) root self.find(x) self.find self find x i for i in range(self.n) if self.find(i) == root for i in range(self.n) if self.find(i) == root i range(self.n) range self.n self n self.find(i) == root self.find(i) self.find self find i root if self.find(i) == root i return [i for i in range(self.n) if self.find(i) == root] [i for i in range(self.n) if self.find(i) == root] self self x x 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 all_group_members(self):
        return {r: self.members(r) for r in self.roots()}

     all_group_members r: self.members(r) for r in self.roots() for r in self.roots() r self.roots() self.roots self roots for r in self.roots() r self.members(r) self.members self members r return {r: self.members(r) for r in self.roots()} {r: self.members(r) for r in self.roots()} self self def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots()) __str__ return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots()) '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots()) '\n'.join '\n' join '{}: {}'.format(r, self.members(r)) '{}: {}'.format '{}: {}' format r self.members(r) self.members self members r self self n,m=mp() n mp() mp m l=[] l [] for i in range(m):
    l.append(lmp()) i range(m) range m l.append(lmp()) l.append l append lmp() lmp ans=[0]*m ans [0]*m [0] 0 m ans[m-1]=n*(n-1)//2 ans[m-1] ans m-1 m 1 n*(n-1)//2 n*(n-1) n n-1 n 1 2 uf=UnionFind(n+1) uf UnionFind(n+1) UnionFind n+1 n 1 for i in range(m-1):
    if not uf.same(l[m-1-i][0],l[m-1-i][1]):
        ans[m-2-i]=ans[m-i-1]-uf.size(l[m-1-i][0])*uf.size(l[m-1-i][1])
        uf.union(l[m-1-i][0],l[m-1-i][1])
    else:
        ans[m-2-i]=ans[m-i-1] i range(m-1) range m-1 m 1 if not uf.same(l[m-1-i][0],l[m-1-i][1]):
        ans[m-2-i]=ans[m-i-1]-uf.size(l[m-1-i][0])*uf.size(l[m-1-i][1])
        uf.union(l[m-1-i][0],l[m-1-i][1])
    else:
        ans[m-2-i]=ans[m-i-1] not uf.same(l[m-1-i][0],l[m-1-i][1]) uf.same(l[m-1-i][0],l[m-1-i][1]) uf.same uf same l[m-1-i][0] [m-1-i] l m-1-i m-1 m 1 i 0 l[m-1-i][1] [m-1-i] l m-1-i m-1 m 1 i 1 ans[m-2-i]=ans[m-i-1]-uf.size(l[m-1-i][0])*uf.size(l[m-1-i][1]) ans[m-2-i] ans m-2-i m-2 m 2 i ans[m-i-1]-uf.size(l[m-1-i][0])*uf.size(l[m-1-i][1]) ans[m-i-1] ans m-i-1 m-i m i 1 uf.size(l[m-1-i][0])*uf.size(l[m-1-i][1]) uf.size(l[m-1-i][0]) uf.size uf size l[m-1-i][0] [m-1-i] l m-1-i m-1 m 1 i 0 uf.size(l[m-1-i][1]) uf.size uf size l[m-1-i][1] [m-1-i] l m-1-i m-1 m 1 i 1 uf.union(l[m-1-i][0],l[m-1-i][1]) uf.union uf union l[m-1-i][0] [m-1-i] l m-1-i m-1 m 1 i 0 l[m-1-i][1] [m-1-i] l m-1-i m-1 m 1 i 1 ans[m-2-i]=ans[m-i-1] ans[m-2-i] ans m-2-i m-2 m 2 i ans[m-i-1] ans m-i-1 m-i m i 1 for a in ans:
    print(a)     a ans print(a) print a def mp(): return map(int,input().split()) def mp(): return map(int,input().split()) mp ans=[0]*m [0]*m ans class UnionFind():
    def __init__(self, n):
        self.n = n
        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

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    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()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots()) class UnionFind():
    def __init__(self, n):
        self.n = n
        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

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    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()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots()) UnionFind l=[] [] l m=mp() mp() m uf=UnionFind(n+1) UnionFind(n+1) uf def lmp(): return list(map(int,input().split())) def lmp(): return list(map(int,input().split())) lmp n,m=mp() mp() n def input(): return sys.stdin.readline().strip() def input(): return sys.stdin.readline().strip() input
import sys
import heapq
import math
import fractions
import bisect
import itertools
from collections import Counter
from collections import deque
from operator import itemgetter
def input(): return sys.stdin.readline().strip()
def mp(): return map(int,input().split())
def lmp(): return list(map(int,input().split()))


class UnionFind():
    def __init__(self, n):
        self.n = n
        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

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    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()}

    def __str__(self):
        return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())

n,m=mp()
l=[]
for i in range(m):
    l.append(lmp())
ans=[0]*m    
ans[m-1]=n*(n-1)//2
uf=UnionFind(n+1)
for i in range(m-1):
    if not uf.same(l[m-1-i][0],l[m-1-i][1]):
        ans[m-2-i]=ans[m-i-1]-uf.size(l[m-1-i][0])*uf.size(l[m-1-i][1])
        uf.union(l[m-1-i][0],l[m-1-i][1])
    else:
        ans[m-2-i]=ans[m-i-1]
for a in ans:
    print(a)    
