#include <stdio.h>
#include <stdlib.h>
 
typedef struct {
    int x;
    int type; // 1 for left edge, -1 for right edge
    int bottomY;
    int topY;
} Event;
 
int compare(const void *a, const void *b) {
    Event *eventA = (Event *)a;
    Event *eventB = (Event *)b;
    if (eventA->x != eventB->x) {
        return eventA->x - eventB->x;
    }
    return eventA->type - eventB->type; // Left edge before right edge
}
 
int calculate_y_length(Event *events, int active_count) {
    int total_length = 0;
    int current_start = -1;
    int current_end = -1;
 
    for (int i = 0; i < active_count; i++) {
        if (events[i].bottomY > current_end) {
            // Non-overlapping interval
            if (current_start != -1) {
                total_length += current_end - current_start;
            }
            current_start = events[i].bottomY;
            current_end = events[i].topY;
        } else {
            // Overlapping interval
            if (events[i].topY > current_end) {
                current_end = events[i].topY;
            }
        }
    }
 
    // Add last active interval
    if (current_start != -1) {
        total_length += current_end - current_start;
    }
 
    return total_length;
}
 
int main() {
    int N, K, L;
    scanf("%d %d %d", &N, &K, &L);
 
    Event *events = malloc(2 * N * sizeof(Event));
    for (int i = 1; i <= N; i++) {
        int leftX = i * K - L;
        int rightX = i * K + L;
        int bottomY = i * K;
        int topY = i * K + L;
 
        // Left edge event
        events[2 * (i - 1)] = (Event){leftX, 1, bottomY, topY};
        // Right edge event
        events[2 * (i - 1) + 1] = (Event){rightX, -1, bottomY, topY};
    }
 
    qsort(events, 2 * N, sizeof(Event), compare);
 
    int area = 0;
    int last_x = events[0].x;
    Event *active_intervals = malloc(2 * N * sizeof(Event));
    int active_count = 0;
 
    for (int i = 0; i < 2 * N; i++) {
        int x = events[i].x;
 
        // Calculate area contribution from last_x to current x
        if (active_count > 0) {
            int y_length = calculate_y_length(active_intervals, active_count);
            area += y_length * (x - last_x);
        }
 
        // Update active intervals
        if (events[i].type == 1) { // Left edge
            active_intervals[active_count++] = events[i];
        } else { // Right edge
            for (int j = 0; j < active_count; j++) {
                if (active_intervals[j].bottomY == events[i].bottomY &&
                    active_intervals[j].topY == events[i].topY) {
                    // Remove the interval
                    active_intervals[j] = active_intervals[--active_count];
                    break;
                }
            }
        }
 
        last_x = x;
    }
 
    printf("%d\n", area);
    free(events);
    free(active_intervals);
    return 0;
}

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