using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

class Solution
{
    static void Main(String[] args)
    {
        var header = Console.ReadLine().Split(' ').Select(s => Int32.Parse(s));
        var n = header.First();
        var i = header.Last();
        
        // The union/find forest will help us keep count of all the astrounauts' countries
        var astrounauts = new UnionFindGraph(n);

        for (int j = 0; j < i; j++)
        {
            var pair = Console.ReadLine().Split(' ').Select(s => Int32.Parse(s)).ToArray();
            var a0 = pair[0];
            var a1 = pair[1];

            // So if two astrounauts belong to the same country they will go in the same tree
            astrounauts.AddEdge(a0, a1);
        }

        // If n is greater than the number of defined vertices in the union/find forest,
        // it means some astrounauts have not been named. I called this condition "hiddenVertices"
        var hiddenVertices = (n > astrounauts.UsedVertices);
        // The roots of the union/find forest represent the various defined countries
        var roots = astrounauts.Roots.ToArray();
        // This array holds the number of astronauts for each country...
        var countriesCount = new long[roots.Length + 1];

        // ... which is nothing more than the size of the country tree!
        for (int j = 0; j < roots.Length; j++)
            countriesCount[j] = astrounauts.GetSize(roots[j]);

        // This is a special value that contains the number of "untold" astronauts
        countriesCount[roots.Length] = (n - astrounauts.UsedVertices);

        long ways = 0;

        // Now to get the total ways we can combine them, just perform a trivial product.
        // Notice that we are including the number of untold astronauts too implicitly in
        // the last slot of the countriesCount array
        for (int j = 0; j < countriesCount.Length; j++)
            for (int h = j + 1; h < countriesCount.Length; h++)
                ways += countriesCount[j] * countriesCount[h];

        // Bonus points: recall that the remaining astronauts belong each one to their own country
        // so we must take into accounts the total number of ways we can combine them too
        if (hiddenVertices)
        {
            var t = countriesCount.Last();
            ways += t * (t - 1) / 2;
        }

        Console.WriteLine(ways);
    }
}

// The following implementation uses several underlying arrays to keep track of vertices.
// I made the choice because the size of this problem is given, and bounded to a reasonable threshold, therefore
// I know for sure that this graph will always fit in memory. Arrays are a nice choice
// because, despite their clumsiness and C-like-ness, they provide fast random access and we
// are working in a case where nodes are uniquely identified by densely packed integers (i.e. the best
// possible case).
// Given the premise, the number of a vertex is used as index and content in these arrays.
// We also need flags that tell us whether the i-th cell refers to an actually used vertex.

class UnionFindGraph
{
    public const int Missing = -1;

    // parents[i] contains the index of the parent of i
    private int[] parents;
    // treeSizes[i] contains the size (height) of the tree that i belongs to
    private int[] treeSizes;
    // used[i] is true iif the vertex i has been used in any edge
    private bool[] used;

    // By construction, vertices that are parents of themselves are the roots of their trees
    public IEnumerable<int> Roots
    {
        get
        {
            for (int i = 0; i < parents.Length; i++)
                if (parents[i] == i)
                    yield return i;
        }
    }

    public int UsedVertices { get; private set; }

    public UnionFindGraph(int size)
    {
        // size is the maximum number of vertices in this tree
        
        this.parents = new int[size];
        this.treeSizes = new int[size];
        this.used = new bool[size];

        this.UsedVertices = 0;

        this.InitializeParents();
    }

    private void InitializeParents()
    {
        // Initially, no vertex has any parent because there is no vertex at all in the graph
        for (int i = 0; i < parents.Length; i++)
            parents[i] = Missing;
    }

    // This is a wrapper for the union routine and handles edge cases like missing roots
    public void AddEdge(int head, int tail)
    {
        int headRoot = GetRoot(head);
        int tailRoot = GetRoot(tail);

        if ((headRoot == Missing) && (tailRoot == Missing))
        {
            // Both vertices don't belong to any connected component. Create a new tree rooted in head
            // with only 2 vertices
            SetParent(head, head);
            SetParent(tail, head);
            SetSize(head, 2);
        }
        else if (headRoot == Missing)
        {
            // Head doesn't belong to any connected component, but tail does. Attach head to the root of
            // the tail component
            SetParent(head, tailRoot);
            SetSize(tailRoot, GetSize(tailRoot) + 1);
        }
        else if (tailRoot == Missing)
        {
            // Tail deson't belong to any connected component, but head does. Attach tail to the root of
            // the head component
            SetParent(tail, headRoot);
            SetSize(headRoot, GetSize(headRoot) + 1);
        }
        else if (headRoot != tailRoot)
        {
            // If headRoot and tailRoot are the same, they already are in the same connected component.
            // Otherwise, merge their connected components.
            Merge(headRoot, tailRoot);
        }

        if (!used[head])
        {
            used[head] = true;
            UsedVertices++;
        }

        if (!used[tail])
        {
            used[tail] = true;
            UsedVertices++;
        }
    }

    // Find
    public int GetRoot(int vertex)
    {
        int parent = parents[vertex];

        if ((parent == vertex) || (parent == Missing))
            return parent;
        else
        {
            // This is path compression: speeds up future queries by attaching
            // this vertex directly to its computed parent, squashing the tree down to a shallower version
            int root = GetRoot(parent);
            SetParent(vertex, root);
            return root;
        }
    }

    public int GetSize(int vertex)
    {
        return treeSizes[GetRoot(vertex)];
    }

    private void SetParent(int vertex, int parent)
    {
        parents[vertex] = parent;
    }

    private void SetSize(int vertex, int size)
    {
        treeSizes[GetRoot(vertex)] = size;
    }

    // Union
    private void Merge(int vertex1, int vertex2)
    {
        int root1 = GetRoot(vertex1);
        int root2 = GetRoot(vertex2);

        if (root1 == root2)
            return;

        int size1 = GetSize(root1);
        int size2 = GetSize(root2);

        // This is the union by rank, where rank in this case is simply called size.
        // It just avoids the formation of long chains by trying to keep tree sizes similar
        
        if (size1 < size2)
        {
            // Attach root1 to root2
            SetParent(root1, root2);
            SetSize(root2, size1 + size2);
        }
        else 
        {
            // Attach root2 to root1
            SetParent(root2, root1);
            SetSize(root1, size1 + size2);
        }
    }
}