import Control.Monad
import Data.Maybe
import qualified Data.ByteString.Char8 as BS
import Data.List
import qualified Data.Vector.Unboxed as VU
import qualified Data.Vector.Unboxed.Mutable as VUM

readInt = fst . fromJust . BS.readInt
readIntList = map readInt . BS.words
getInt = readInt <$> BS.getLine
getIntList = readIntList <$> BS.getLine

newUF n = VUM.replicate n (-1 :: Int)

root uf x = do
    p <- VUM.read uf x
    if p < 0
        then return x
        else do
            r <- root uf p
            VUM.write uf x r
            return r

same uf x y = liftM2 (==) (root uf x) (root uf y)

unite uf x y = do
    px <- root uf x
    py <- root uf y
    when (px /= py) $ do
        sx <- VUM.read uf px
        sy <- VUM.read uf py
        let (par, chld) = if sx < sy then (px, py)　else (py, px)
        VUM.write uf chld par
        VUM.write uf par (sx + sy) 

size uf x = do
    px <- root uf x
    s <- VUM.read uf px
    return $ abs s

main = do
    [n,m] <- getIntList
    ab <- fmap VU.fromList $ replicateM m $ do
        [a,b] <- getIntList
        return (a-1,b-1)
    
    let result = VU.create $ do
            vec <- VUM.replicate (m+1) (0::Int) 
            VUM.write vec m $ n * (n-1) `div` 2
            uf <- newUF n
            forM_ [m-1,m-2..0] $ \i -> do
                let (x, y) = ab VU.! i
                b <- same uf x y
                a <- VUM.read vec (i+1)
                if b then
                    VUM.write vec i a
                else do
                    nx <- size uf x
                    ny <- size uf y
                    unite uf x y
                    VUM.write vec i $ a - (nx * ny)
            return vec
    
    forM_ [1..m] $ \i -> do
        print $ result VU.! i