class UnionFind():
    def __init__(self,n):
        self.n=n
        self.root=[-1]*n
        self.rank=[-1]*n

    def Find_Root(self,x):
        if self.root[x]<0:return x
        else:
            self.root[x]=self.Find_Root(self.root[x])
            return self.root[x]

    def Unite(self,x,y):
        x=self.Find_Root(x)
        y=self.Find_Root(y)

        if x==y:return
        elif self.rank[x]>self.rank[y]:
            self.root[x] +=self.root[y]
            self.root[y]=x
        else:
            self.root[y] +=self.root[x]
            self.root[x]=y
            if self.rank[x]==self.rank[y]:
                self.rank[y] +=1

    def isSameGroup(self,x,y):
        return self.Find_Root(x)==self.Find_Root(y)

    def size(self,x):
        return -self.root[self.Find_Root(x)]

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

    def roots(self):
        return[i for i,j in enumerate(self.root) if j<0]

    def group_members(self):
        return {i:self.members(i) for i in self.roots()}

    def group_count(self):
        return len(self.roots())


n,m=map(int,input().split())
AB=[list(map(int,input().split())) for _ in range(m)]

ans=[n*(n-1)//2]
UnionFind=UnionFind(n+1)
for a,b in AB[::-1]:
    if UnionFind.isSameGroup(a,b):ans.append(ans[-1])
    else:ans.append(ans[-1]-UnionFind.size(a)*UnionFind.size(b))
    UnionFind.Unite(a,b)

for i in ans[::-1][1:]:
    print(i) class UnionFind():
    def __init__(self,n):
        self.n=n
        self.root=[-1]*n
        self.rank=[-1]*n

    def Find_Root(self,x):
        if self.root[x]<0:return x
        else:
            self.root[x]=self.Find_Root(self.root[x])
            return self.root[x]

    def Unite(self,x,y):
        x=self.Find_Root(x)
        y=self.Find_Root(y)

        if x==y:return
        elif self.rank[x]>self.rank[y]:
            self.root[x] +=self.root[y]
            self.root[y]=x
        else:
            self.root[y] +=self.root[x]
            self.root[x]=y
            if self.rank[x]==self.rank[y]:
                self.rank[y] +=1

    def isSameGroup(self,x,y):
        return self.Find_Root(x)==self.Find_Root(y)

    def size(self,x):
        return -self.root[self.Find_Root(x)]

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

    def roots(self):
        return[i for i,j in enumerate(self.root) if j<0]

    def group_members(self):
        return {i:self.members(i) for i in self.roots()}

    def group_count(self):
        return len(self.roots()) UnionFind def __init__(self,n):
        self.n=n
        self.root=[-1]*n
        self.rank=[-1]*n

     __init__ self.n=n self.n self n n self.root=[-1]*n self.root self root [-1]*n [-1] -1 n self.rank=[-1]*n self.rank self rank [-1]*n [-1] -1 n self self n n def Find_Root(self,x):
        if self.root[x]<0:return x
        else:
            self.root[x]=self.Find_Root(self.root[x])
            return self.root[x]

     Find_Root if self.root[x]<0:return x
        else:
            self.root[x]=self.Find_Root(self.root[x])
            return self.root[x]

     self.root[x]<0 self.root[x] self.root self root x 0 self.root[x]=self.Find_Root(self.root[x]) self.root[x] self.root self root x self.Find_Root(self.root[x]) self.Find_Root self Find_Root self.root[x] self.root self root x return self.root[x] self.root[x] self.root self root x self self x x def Unite(self,x,y):
        x=self.Find_Root(x)
        y=self.Find_Root(y)

        if x==y:return
        elif self.rank[x]>self.rank[y]:
            self.root[x] +=self.root[y]
            self.root[y]=x
        else:
            self.root[y] +=self.root[x]
            self.root[x]=y
            if self.rank[x]==self.rank[y]:
                self.rank[y] +=1

     Unite x=self.Find_Root(x) x self.Find_Root(x) self.Find_Root self Find_Root x y=self.Find_Root(y) y self.Find_Root(y) self.Find_Root self Find_Root y if x==y:return
        elif self.rank[x]>self.rank[y]:
            self.root[x] +=self.root[y]
            self.root[y]=x
        else:
            self.root[y] +=self.root[x]
            self.root[x]=y
            if self.rank[x]==self.rank[y]:
                self.rank[y] +=1

     x==y x y elif self.rank[x]>self.rank[y]:
            self.root[x] +=self.root[y]
            self.root[y]=x
         self.rank[x]>self.rank[y] self.rank[x] self.rank self rank x self.rank[y] self.rank self rank y self.root[x] +=self.root[y] self.root[x] self.root self root x self.root[y] self.root self root y self.root[y]=x self.root[y] self.root self root y x self.root[y] +=self.root[x] self.root[y] self.root self root y self.root[x] self.root self root x self.root[x]=y self.root[x] self.root self root x y if self.rank[x]==self.rank[y]:
                self.rank[y] +=1

     self.rank[x]==self.rank[y] self.rank[x] self.rank self rank x self.rank[y] self.rank self rank y self.rank[y] +=1 self.rank[y] self.rank self rank y 1 self self x x y y def isSameGroup(self,x,y):
        return self.Find_Root(x)==self.Find_Root(y)

     isSameGroup return self.Find_Root(x)==self.Find_Root(y) self.Find_Root(x)==self.Find_Root(y) self.Find_Root(x) self.Find_Root self Find_Root x self.Find_Root(y) self.Find_Root self Find_Root y self self x x y y def size(self,x):
        return -self.root[self.Find_Root(x)]

     size return -self.root[self.Find_Root(x)] -self.root[self.Find_Root(x)] self.root[self.Find_Root(x)] self.root self root self.Find_Root(x) self.Find_Root self Find_Root x self self x x def members(self,x):
        root=self.Find_Root(x)
        return [i for i in range(self.n) if self.Find_Root(i)==root]

     members root=self.Find_Root(x) root self.Find_Root(x) self.Find_Root self Find_Root x i for i in range(self.n) if self.Find_Root(i)==root for i in range(self.n) if self.Find_Root(i)==root i range(self.n) range self.n self n self.Find_Root(i)==root self.Find_Root(i) self.Find_Root self Find_Root i root if self.Find_Root(i)==root i return [i for i in range(self.n) if self.Find_Root(i)==root] [i for i in range(self.n) if self.Find_Root(i)==root] self self x x def roots(self):
        return[i for i,j in enumerate(self.root) if j<0]

     roots i for i,j in enumerate(self.root) if j<0 for i,j in enumerate(self.root) if j<0 i j enumerate(self.root) enumerate self.root self root j<0 j 0 if j<0 i return[i for i,j in enumerate(self.root) if j<0] [i for i,j in enumerate(self.root) if j<0] self self def group_members(self):
        return {i:self.members(i) for i in self.roots()}

     group_members i:self.members(i) for i in self.roots() for i in self.roots() i self.roots() self.roots self roots for i in self.roots() i self.members(i) self.members self members i return {i:self.members(i) for i in self.roots()} {i:self.members(i) for i in self.roots()} 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 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(map(int,input().split())) for _ in range(m)] AB [list(map(int,input().split())) for _ in range(m)] ans=[n*(n-1)//2] ans [n*(n-1)//2] n*(n-1)//2 n*(n-1) n n-1 n 1 2 UnionFind=UnionFind(n+1) UnionFind UnionFind(n+1) UnionFind n+1 n 1 for a,b in AB[::-1]:
    if UnionFind.isSameGroup(a,b):ans.append(ans[-1])
    else:ans.append(ans[-1]-UnionFind.size(a)*UnionFind.size(b))
    UnionFind.Unite(a,b) a b AB[::-1] AB ::-1 -1 if UnionFind.isSameGroup(a,b):ans.append(ans[-1])
    else:ans.append(ans[-1]-UnionFind.size(a)*UnionFind.size(b))
     UnionFind.isSameGroup(a,b) UnionFind.isSameGroup UnionFind isSameGroup a b UnionFind.Unite(a,b) UnionFind.Unite UnionFind Unite a b for i in ans[::-1][1:]:
    print(i) i ans[::-1][1:] [::-1] ans ::-1 -1 1: 1 print(i) print i AB=[list(map(int,input().split())) for _ in range(m)] [list(map(int,input().split())) for _ in range(m)] AB ans=[n*(n-1)//2] [n*(n-1)//2] ans n,m=map(int,input().split()) map(int,input().split()) n m=map(int,input().split()) map(int,input().split()) m UnionFind=UnionFind(n+1) UnionFind(n+1) UnionFind class UnionFind():
    def __init__(self,n):
        self.n=n
        self.root=[-1]*n
        self.rank=[-1]*n

    def Find_Root(self,x):
        if self.root[x]<0:return x
        else:
            self.root[x]=self.Find_Root(self.root[x])
            return self.root[x]

    def Unite(self,x,y):
        x=self.Find_Root(x)
        y=self.Find_Root(y)

        if x==y:return
        elif self.rank[x]>self.rank[y]:
            self.root[x] +=self.root[y]
            self.root[y]=x
        else:
            self.root[y] +=self.root[x]
            self.root[x]=y
            if self.rank[x]==self.rank[y]:
                self.rank[y] +=1

    def isSameGroup(self,x,y):
        return self.Find_Root(x)==self.Find_Root(y)

    def size(self,x):
        return -self.root[self.Find_Root(x)]

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

    def roots(self):
        return[i for i,j in enumerate(self.root) if j<0]

    def group_members(self):
        return {i:self.members(i) for i in self.roots()}

    def group_count(self):
        return len(self.roots()) class UnionFind():
    def __init__(self,n):
        self.n=n
        self.root=[-1]*n
        self.rank=[-1]*n

    def Find_Root(self,x):
        if self.root[x]<0:return x
        else:
            self.root[x]=self.Find_Root(self.root[x])
            return self.root[x]

    def Unite(self,x,y):
        x=self.Find_Root(x)
        y=self.Find_Root(y)

        if x==y:return
        elif self.rank[x]>self.rank[y]:
            self.root[x] +=self.root[y]
            self.root[y]=x
        else:
            self.root[y] +=self.root[x]
            self.root[x]=y
            if self.rank[x]==self.rank[y]:
                self.rank[y] +=1

    def isSameGroup(self,x,y):
        return self.Find_Root(x)==self.Find_Root(y)

    def size(self,x):
        return -self.root[self.Find_Root(x)]

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

    def roots(self):
        return[i for i,j in enumerate(self.root) if j<0]

    def group_members(self):
        return {i:self.members(i) for i in self.roots()}

    def group_count(self):
        return len(self.roots()) UnionFind
class UnionFind():
    def __init__(self,n):
        self.n=n
        self.root=[-1]*n
        self.rank=[-1]*n

    def Find_Root(self,x):
        if self.root[x]<0:return x
        else:
            self.root[x]=self.Find_Root(self.root[x])
            return self.root[x]

    def Unite(self,x,y):
        x=self.Find_Root(x)
        y=self.Find_Root(y)

        if x==y:return
        elif self.rank[x]>self.rank[y]:
            self.root[x] +=self.root[y]
            self.root[y]=x
        else:
            self.root[y] +=self.root[x]
            self.root[x]=y
            if self.rank[x]==self.rank[y]:
                self.rank[y] +=1

    def isSameGroup(self,x,y):
        return self.Find_Root(x)==self.Find_Root(y)

    def size(self,x):
        return -self.root[self.Find_Root(x)]

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

    def roots(self):
        return[i for i,j in enumerate(self.root) if j<0]

    def group_members(self):
        return {i:self.members(i) for i in self.roots()}

    def group_count(self):
        return len(self.roots())


n,m=map(int,input().split())
AB=[list(map(int,input().split())) for _ in range(m)]

ans=[n*(n-1)//2]
UnionFind=UnionFind(n+1)
for a,b in AB[::-1]:
    if UnionFind.isSameGroup(a,b):ans.append(ans[-1])
    else:ans.append(ans[-1]-UnionFind.size(a)*UnionFind.size(b))
    UnionFind.Unite(a,b)

for i in ans[::-1][1:]:
    print(i)