#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

typedef struct {
    int* data;
    int front, rear, capacity;
} Queue;

Queue* createQueue(int capacity) {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->capacity = capacity;
    q->data = (int*)malloc(capacity * sizeof(int));
    q->front = q->rear = 0;
    return q;
}

void enqueue(Queue* q, int val) {
    q->data[q->rear++] = val;
}

int dequeue(Queue* q) {
    return q->data[q->front++];
}

bool isEmpty(Queue* q) {
    return q->front == q->rear;
}

int bfs(int** graph, int* graphSize, int start, bool* visited, int n) {
    Queue* queue = createQueue(n);
    enqueue(queue, start);
    visited[start] = true;
    int size = 0;
    
    while (!isEmpty(queue)) {
        int node = dequeue(queue);
        size++;
        for (int i = 0; i < graphSize[node]; i++) {
            int neighbor = graph[node][i];
            if (!visited[neighbor]) {
                visited[neighbor] = true;
                enqueue(queue, neighbor);
            }
        }
    }
    
    free(queue->data);
    free(queue);
    return size;
}

long long solution(int n, int** edges, int edgesSize) {
    int** graph = (int**)malloc(n * sizeof(int*));
    int* graphSize = (int*)calloc(n, sizeof(int));
    bool* visited = (bool*)calloc(n, sizeof(bool));
    
    for (int i = 0; i < n; i++) {
        graph[i] = (int*)malloc(n * sizeof(int));
    }
    
    for (int i = 0; i < edgesSize; i++) {
        int a = edges[i][0], b = edges[i][1];
        graph[a][graphSize[a]++] = b;
        graph[b][graphSize[b]++] = a;
    }
    
    int componentSizes[n];
    int numComponents = 0;
    
    // Find all connected components using BFS
    for (int i = 0; i < n; i++) {
        if (!visited[i]) {
            int componentSize = bfs(graph, graphSize, i, visited, n);
            componentSizes[numComponents++] = componentSize;
        }
    }
    
    // Calculate unreachable pairs
    long long totalPairs = 0;
    long long remainingNodes = n;
    
    for (int i = 0; i < numComponents; i++) {
        remainingNodes -= componentSizes[i];
        totalPairs += (long long)componentSizes[i] * remainingNodes;
    }
    
    for (int i = 0; i < n; i++) {
        free(graph[i]);
    }
    free(graph);
    free(graphSize);
    free(visited);
    
    return totalPairs;
}

int main() {
    int n;
    scanf("%d", &n);
    
    // Simple parsing - assume small input for demo
    int edgesSize = 0;
    int** edges = (int**)malloc(100 * sizeof(int*));
    for (int i = 0; i < 100; i++) {
        edges[i] = (int*)malloc(2 * sizeof(int));
    }
    
    printf("%lld\n", solution(n, edges, edgesSize));
    return 0;
}