public static int journeyToMoon(int n, List<List<Integer>> astronaut) {
        // Write your code here
        Map<Integer, List<Integer>> adj = buildAdjList(n, astronaut);

        Set<Integer> visited = new HashSet<>();
        Set<Set<Integer>> countries = new HashSet<>();
        for (int i=0;i<n;i++) {
            if (!visited.contains(i)) {
                Set<Integer> astronautInCountry = new HashSet<>();
                
                dfsVisit(adj, i, visited, astronautInCountry);
                
                countries.add(astronautInCountry);
            }
        }
        long result = 0;
        for (Set<Integer> country : countries) {
				// If choose 1st atronaut from country, there are (n - country.size()) astronaut to choose 2nd.
            result += (country.size() * (n - country.size()));
        }
        return (int)(result / 2);
    }
    
    private static void dfsVisit(final Map<Integer, List<Integer>> adj, int node, Set<Integer> visited, Set<Integer> astronautInCountry) {
        visited.add(node);
        astronautInCountry.add(node);
        
        for (int neighbor : adj.get(node)) {
            if (!visited.contains(neighbor)) {
                dfsVisit(adj, neighbor, visited, astronautInCountry);
            }
        }
    }
    
    private static Map<Integer, List<Integer>> buildAdjList(int n, List<List<Integer>> astronaut) {
        Map<Integer, List<Integer>> adj = new HashMap<>();
        
        for (int i=0; i<n; i++) {
            adj.put(i, new ArrayList<>());
        }
        for (List<Integer> edge : astronaut ) {
            adj.get(edge.get(0)).add(edge.get(1));
            adj.get(edge.get(1)).add(edge.get(0));
        }
        
        return adj;
    }

#include <cmath>
#include <cstdio>
#include <vector>
#include <iostream>
#include <algorithm>

using namespace std;


static inline int Count(const std::vector<int> &groups, int head)
    {
    return -groups[head];
    }

static int Find(std::vector<int> &groups, int node)
    {
    if (groups[node] < 0)
        return node;
    return (groups[node] = Find(groups, groups[node]));
    }

static void Union(std::vector<int> &groups, int a, int b)
    {
    int parentA = Find(groups, a);
    int parentB = Find(groups, b);

        if (parentA == parentB)
            return;

    int countA   = Count(groups, parentA);
    int countB   = Count(groups, parentB);
    int newCount = countA + countB;

        if (countA > countB) {
            groups[parentB] = parentA;
            groups[parentA] = -newCount;
        } else {
            groups[parentA] = parentB;
            groups[parentB] = -newCount;
        }
    }

int main(void)
    {
        int n, p;

        std::cin >> n >> p;
        std::vector<int> groups(n, -1);

        for (int i = 0; i < p; i++) {
            int a, b;
            std::cin >> a >> b;
            Union(groups, a, b);
        }

        long long total     = 0;
        long long prevCount = 0;
        for (int i = 0; i < n; i++) {
            if (Find(groups, i) == i) {
                int count = Count(groups, i);

                total     += count * prevCount;
                prevCount += count;
            }
        }

        std::cout << total << "\n";
    }