using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using static ABC120_2.Util;
 
namespace ABC120_2
{
    class Program2
    {
        static void Main(string[] args)
        {
#if DEBUG
            while (true)
            {
#endif
                // 2019/05/01
                // FavoriteSound();    //  5m -> 4m
                // KthCommonDivisor(); // 27m -> 12m
                // Unification();      // 52m -> 17m
                DecayedBridges();
#if DEBUG
            }
#endif
        }
 
        static void DecayedBridges()
        {
            IO.StreamScanner scanner = new IO.StreamScanner(Console.OpenStandardInput());
            var n = scanner.Integer();
            var m = scanner.Integer();
            var bridges = new List<Tuple<int, int>>();
            for (int i = 0; i < m; i++) bridges.Add(new Tuple<int, int>(scanner.Integer(), scanner.Integer()));
 
            var ret = new List<long>();
            var cur = 0L;
            for (int i = 1; i < n; i++) cur += i;
 
            var uf = new UnionFind2();
            bridges.Reverse();
            ret.Add(cur);
 
            foreach (var b in bridges.Take(bridges.Count() - 1))
            {
                var r1 = uf.Root(b.Item1);
                var r2 = uf.Root(b.Item2);
 
                if (!uf.IsSameGroup(b.Item1, b.Item2))
                {
                    cur -= (uf.Num(b.Item1) * uf.Num(b.Item2));
                    uf.Unite(b.Item1, b.Item2);
                }
                ret.Add(cur);
            }
 
            ret.Reverse();
            // Console.WriteLineだと通らない
            foreach (var a in ret) IO.Printer.Out.WriteLine(a);
            IO.Printer.Out.Flush();
 
        }
 
        static void Unification()
        {
            int[] cubes = ReadIntArrayFromBinaryString();
 
            int zeroCnt = 0;
            int oneCnt = 0;
            foreach(var cube in cubes)
            {
                if (cube == 0)
                {
                    zeroCnt++;
                }
                else
                {
                    oneCnt++;
                }
            }
 
            int ans = Math.Min(zeroCnt,oneCnt) * 2;
 
            Console.WriteLine(ans);
        }
 
        static void KthCommonDivisor()
        {
            int[] tmp = ReadIntArray();
            int A = tmp[0];
            int B = tmp[1];
            int K = tmp[2];
 
            int[] aDivisor = GetDivisor(A);
 
            Array.Reverse(aDivisor);
 
            int cnt = 0;
            int ans = 0;
            foreach (int d in aDivisor)
            {
                if (B % d == 0)
                {
                    cnt++;
                    if (cnt == K)
                    {
                        ans = d;
                        break;
                    }
                }
            }
 
            Console.WriteLine(ans);
        }
 
        static int[] GetDivisor(int n)
        {
            double sqrt = Math.Sqrt(n);
 
            List<int> divisor = new List<int>();
 
            for (int i = 1; i <= sqrt; i++)
            {
                if (n % i == 0)
                {
                    divisor.Add(i);
                    int tmp = n / i;
                    if (tmp != i)
                    {
                        divisor.Add(tmp);
                    }
                }
            }
 
            return Sort(divisor.ToArray());
        }
 
        static void FavoriteSound()
        {
            int[] tmp = ReadIntArray();
            int A = tmp[0];
            int B = tmp[1];
            int C = tmp[2];
 
            int ans = Math.Min(B / A, C);
 
            Console.WriteLine(ans);
        }
    }
 
    #region common
 
    /// <summary>
    /// ユーティリティー
    /// </summary>
    public static class Util
    {
        public static int ReadInt()
        {
            return int.Parse(Console.ReadLine());
        }
 
        public static int[] ReadIntArray()
        {
            return Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
        }
 
        public static long ReadLong()
        {
            return long.Parse(Console.ReadLine());
        }
        public static long[] ReadLongArray()
        {
            return Console.ReadLine().Split(' ').Select(long.Parse).ToArray();
        }
 
        public static string ReadString()
        {
            return Console.ReadLine();
        }
 
        /// <summary>
        /// "00101001010"という様な入力をintの配列にして返す
        /// </summary>
        /// <returns></returns>
        public static int[] ReadIntArrayFromBinaryString()
        {
            return Console.ReadLine().Select(c => int.Parse(c.ToString())).ToArray();
        }
 
        /// <summary>
        /// "00101001010"という様な入力をboolの配列にして返す
        /// </summary>
        /// <returns></returns>
        public static bool[] ReadBoolArrayFromBinaryString()
        {
            return Console.ReadLine().Select(c => c == '1').ToArray();
        }
 
        /// <summary>
        /// ソートをして結果を返します。
        /// 破壊的関数です。
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="array"></param>
        /// <returns></returns>
        public static T[] Sort<T>(T[] array)
        {
            Array.Sort<T>(array);
            return array;
        }
 
        /// <summary>
        /// 逆順ソートをして結果を返します。
        /// 破壊的関数です。
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="array"></param>
        /// <returns></returns>
        public static T[] ReverseSort<T>(T[] array)
        {
            Array.Sort<T>(array);
            Array.Reverse(array);
            return array;
        }
 
        /// <summary>
        /// Rubyにあるようなやつ
        /// ex) 5.Times(i => Console.WriteLine(i));
        /// </summary>
        /// <param name="times"></param>
        /// <param name="action"></param>
        public static void Times(this int times, Action<int> action)
        {
            for (int i = 0; i < times; i++)
            {
                action(i);
            }
        }
 
        /// <summary>
        /// 引数aと引数bの値を入れ替えます
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="a"></param>
        /// <param name="b"></param>
        public static void Swap<T>(ref T a, ref T b)
        {
            T _a = a;
            a = b;
            b = _a;
        }
    }
 
    /// <summary>
    /// HashSetの等値性判定方法を指定したいときに使います。HashSetのコンストラクタに渡して使います。
    /// EqualsとGetHashCodeを提供します。IEqualityComparer<T>を実装するクラスです。
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class EqualityComparer<T> : IEqualityComparer<T>
    {
        private Func<T, T, bool> _equals;
        private Func<T, int> _getHashCode;
 
        public EqualityComparer(Func<T, T, bool> equals, Func<T, int> getHashCode)
        {
            _equals = equals;
            _getHashCode = getHashCode;
        }
 
        public bool Equals(T x, T y)
        {
            return _equals(x, y);
        }
 
        public int GetHashCode(T obj)
        {
            return _getHashCode(obj);
        }
    }
 
    
    public class UnionFind2
    {
        public class Node
        {
            public Node Parent { get; set; }
            public int Rank { get; set; }
            public int Count { get; set; } = 1;  // node count under the same group, valid only at the root node
        }
 
        private Dictionary<object, Node> _dict = new Dictionary<object, Node>();
 
        public Node Root(object data)
        {
            if (!_dict.ContainsKey(data))
            {
                var node = new Node();
                _dict.Add(data, node);
                return node;
            }
            else
            {
                var node = _dict[data];
                return Find(node);
            }
        }
 
        private Node Find(Node node)
        {
            if (node.Parent == null) return node;
            return node.Parent = Find(node.Parent);
        }
 
        public void Unite(IComparable x, IComparable y)
        {
            var xRoot = Root(x);
            var yRoot = Root(y);
            if (xRoot == yRoot) return;
 
            if (xRoot.Rank < yRoot.Rank)
            {
                xRoot.Parent = yRoot;
                yRoot.Count += xRoot.Count;
            }
            else
            {
                yRoot.Parent = xRoot;
                if (xRoot.Rank == yRoot.Rank) yRoot.Rank++;
                xRoot.Count += yRoot.Count;
            }
        }
 
        public bool IsSameGroup(IComparable x, IComparable y)
        {
            return Root(x) == Root(y);
        }
 
        public int Num(object data)
        {
            return Root(data).Count;
        }
    }
 
    /// <summary>
    /// UnionFindTree
    /// </summary>
    public class UnionFindTree
    {
        int[] Node;
 
        public UnionFindTree(int N)
        {
            Node = new int[N];
            for (int i = 0; i < N; i++)
            {
                Node[i] = -1;
            }
        }
 
        public bool IsSameGroup(int x, int y)
        {
            return GetRoot(x) == GetRoot(y);
        }
 
        public bool Merge(int x, int y)
        {
            int xr = GetRoot(x);
            int yr = GetRoot(y);
 
            if (xr == yr)
                return false;
 
            // xが、大きなグループを示すようにSwapする（値が小さい方が大きなグループ）
            if (Node[xr] > Node[yr])
                Swap(ref xr, ref yr);
 
            // グループの数を合算する
            Node[xr] += Node[yr];
 
            // 根を張り替える
            Node[yr] = x;
            return true;
        }
 
        public int Size(int x)
        {
            return -Node[GetRoot(x)];
        }
 
        public int GetRoot(int n)
        {
            if (Node[n] < 0)
            {
                return n;
            }
            else
            {
                // 根を張りなおす。
                Node[n] = GetRoot(Node[n]);
                return Node[n];
            }
        }
    }
 
    /// <summary>
    /// PriorityQueue
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class PriorityQueue<T> where T : IComparable
    {
        private Comparison<T> _comparison = null;
        private int _type = 0;
 
        private T[] _heap;
        private int _sz = 0;
 
        private int _count = 0;
 
        /// <summary>
        /// Priority queue
        /// </summary>
        /// <param name="maxSize">max size</param>
        /// <param name="type">0: asc, 1:desc</param>
        public PriorityQueue(int maxSize, int type = 0)
        {
            _heap = new T[maxSize];
            _type = type;
        }
 
        public PriorityQueue(int maxSize, Comparison<T> comparison)
        {
            _heap = new T[maxSize];
            _comparison = comparison;
        }
 
        private int Compare(T x, T y)
        {
            if (_comparison != null) return _comparison(x, y);
            return _type == 0 ? x.CompareTo(y) : y.CompareTo(x);
        }
 
        public void Push(T x)
        {
            _count++;
 
            //node number
            var i = _sz++;
 
            while (i > 0)
            {
                //parent node number
                var p = (i - 1) / 2;
 
                if (Compare(_heap[p], x) <= 0) break;
 
                _heap[i] = _heap[p];
                i = p;
            }
 
            _heap[i] = x;
        }
 
        public T Pop()
        {
            _count--;
 
            T ret = _heap[0];
            T x = _heap[--_sz];
 
            int i = 0;
            while (i * 2 + 1 < _sz)
            {
                //children
                int a = i * 2 + 1;
                int b = i * 2 + 2;
 
                if (b < _sz && Compare(_heap[b], _heap[a]) < 0) a = b;
 
                if (Compare(_heap[a], x) >= 0) break;
 
                _heap[i] = _heap[a];
                i = a;
            }
 
            _heap[i] = x;
 
            return ret;
        }
 
        public int Count()
        {
            return _count;
        }
 
        public T Peek()
        {
            return _heap[0];
        }
 
        public bool Contains(T x)
        {
            for (int i = 0; i < _sz; i++) if (x.Equals(_heap[i])) return true;
            return false;
        }
 
        public void Clear()
        {
            while (this.Count() > 0) this.Pop();
        }
 
        public IEnumerator<T> GetEnumerator()
        {
            var ret = new List<T>();
 
            while (this.Count() > 0)
            {
                ret.Add(this.Pop());
            }
 
            foreach (var r in ret)
            {
                this.Push(r);
                yield return r;
            }
        }
 
        public T[] ToArray()
        {
            T[] array = new T[_sz];
            int i = 0;
 
            foreach (var r in this)
            {
                array[i++] = r;
            }
 
            return array;
        }
    }
 
    #endregion
}
 
namespace IO
{
    using System.IO;
    using System.Text;
    using System.Globalization;
 
    public class Printer : StreamWriter
    {
        static Printer()
        {
            Out = new Printer(Console.OpenStandardOutput()) { AutoFlush = false };
        }
 
        public static Printer Out { get; set; }
 
        public override IFormatProvider FormatProvider
        {
            get { return CultureInfo.InvariantCulture; }
        }
 
        public Printer(Stream stream)
            : base(stream, new UTF8Encoding(false, true))
        {
        }
 
        public Printer(Stream stream, Encoding encoding)
            : base(stream, encoding)
        {
        }
 
        public void Write<T>(string format, T[] source)
        {
            base.Write(format, source.OfType<object>().ToArray());
        }
 
        public void WriteLine<T>(string format, T[] source)
        {
            base.WriteLine(format, source.OfType<object>().ToArray());
        }
    }
 
    public class StreamScanner
    {
        public StreamScanner(Stream stream)
        {
            str = stream;
        }
 
        public readonly Stream str;
        private readonly byte[] buf = new byte[1024];
        private int len, ptr;
        public bool isEof;
 
        public bool IsEndOfStream
        {
            get { return isEof; }
        }
 
        private byte read()
        {
            if (isEof) return 0;
            if (ptr < len) return buf[ptr++];
            ptr = 0;
            if ((len = str.Read(buf, 0, 1024)) > 0) return buf[ptr++];
            isEof = true;
            return 0;
        }
 
        public char Char()
        {
            byte b;
            do b = read(); while ((b < 33 || 126 < b) && !isEof);
            return (char)b;
        }
 
        public string Scan()
        {
            var sb = new StringBuilder();
            for (var b = Char(); b >= 33 && b <= 126; b = (char)read())
                sb.Append(b);
            return sb.ToString();
        }
 
        public string ScanLine()
        {
            var sb = new StringBuilder();
            for (var b = Char(); b != '\n'; b = (char)read())
                if (b == 0) break;
                else if (b != '\r') sb.Append(b);
            return sb.ToString();
        }
 
        public long Long()
        {
            if (isEof) return long.MinValue;
            long ret = 0;
            byte b;
            var ng = false;
            do b = read(); while (b != 0 && b != '-' && (b < '0' || '9' < b));
            if (b == 0) return long.MinValue;
            if (b == '-')
            {
                ng = true;
                b = read();
            }
            for (; ; b = read())
            {
                if (b < '0' || '9' < b)
                    return ng ? -ret : ret;
                ret = ret * 10 + b - '0';
            }
        }
 
        public int Integer()
        {
            return (isEof) ? int.MinValue : (int)Long();
        }
 
        public double Double()
        {
            var s = Scan();
            return s != "" ? double.Parse(s, CultureInfo.InvariantCulture) : double.NaN;
        }
 
        static T[] enumerate<T>(int n, Func<T> f)
        {
            var a = new T[n];
            for (int i = 0; i < n; ++i) a[i] = f();
            return a;
        }
 
        public char[] Char(int n)
        {
            return enumerate(n, Char);
        }
 
        public string[] Scan(int n)
        {
            return enumerate(n, Scan);
        }
 
        public double[] Double(int n)
        {
            return enumerate(n, Double);
        }
 
        public int[] Integer(int n)
        {
            return enumerate(n, Integer);
        }
 
        public long[] Long(int n)
        {
            return enumerate(n, Long);
        }
    }
}

Measured memory_bytes: 35504