import java.util.*;

/**
 * Use a greedy algorithm and a segment tree.
 * Process the days in order. On each day we will pay for the smallest
 * number of flights such that there are enough flights leftover in the
 * following months that we can meet the minimum number that we need to
 * pay for.
 * We do this with a segment tree where each leaf node corresponds to an
 * interval of m months. We store the value for
 * excess_flights_left_in_interval.
 * If we do not choose all flights on some day, then we decrease the excess
 * in all remaining flights in the interval by the amount of flights that
 * we chose not to take.
 * Use lazy propagation in the segment tree to make the range updates O(log n).
 *      Time complexity: O(n log n)
 *
 * @author Finn Lidbetter
 */

public class frequent_flier_finn {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        long k = sc.nextInt();
        long[] flights = new long[n + 2*(m-1)];
        for (int i=0; i<n; i++) {
            flights[i+m-1] = sc.nextInt();
        }
        long[] prefixSum = new long[flights.length];
        for (int i=1; i < flights.length; i++) {
            prefixSum[i] = prefixSum[i - 1] + flights[i];
        }
        // Each leaf node corresponds to an interval of size m.
        // Each leaf node stores the value for excess_flights_left_in_interval.
        // Initially this is (flights_in_interval - k).
        // If we do not use all flights on some day, then we subtract the
        // the difference from the excess for all remaining intervals containing
        // this day.
        Node segTree = new Node(0, n+(m-1));
        for (int i=0; i<n+m-1; i++) {
            if (i==0) {
                segTree.update(i, i + 1, prefixSum[i + m - 1] - k);
            } else {
                segTree.update(i, i + 1, prefixSum[i + m - 1] - prefixSum[i - 1] - k);
            }
        }
        long[] paidFor = new long[n];
        for (int i=0; i<n; i++) {
            // Get the most restrictive interval.
            long smallestExcess = segTree.min(i, i+m);
            if (smallestExcess > 0) {
                if (smallestExcess > flights[i+m-1]) {
                    smallestExcess = flights[i+m-1];
                }
                paidFor[i] = flights[i+m-1] - smallestExcess;
                segTree.update(i+1, i+m, - smallestExcess);
            } else {
                paidFor[i] = flights[i+m-1];
            }
        }
        long paidSum = 0;
        for (int i=0; i<n; i++) {
            paidSum += paidFor[i];
        }
        System.out.println(paidSum);
    }
}
class Node {
    static final long INF = Long.MAX_VALUE;
    long minPos, maxPos, min = 0, lazy = 0;
    Node left, right;
    public Node(long l, long r) {
        minPos = l; maxPos = r;
        if (l == r - 1L) {
            left = right = null;
        } else {
            long mid = (l + r) / 2L;
            left = new Node(l, mid);
            right = new Node(mid, r);
        }
    }
    public void update(long l, long r, long change) { // Adjust [l, r)
        propagate(); // Do lazy updates to children
        if (l <= minPos && maxPos <= r) { // Node's range fits in query range
            min += change;
            // Lazily propagate update to children
            if (left != null) {
                left.lazy += change;
            }
            if (right != null) {
                right.lazy += change;
            }
        } else if (!(r <= minPos || l >= maxPos)) { // Partial overlap
            if (left != null) {
                left.update(l, r, change);
            }
            if (right != null) {
                right.update(l, r, change);
            }
            min = Math.min(
                    (left == null ? INF : left.min),
                    (right == null ? INF : right.min)
            );
        }
    }
    public long min(long l, long r) { // Get min value in interval [l, r)
        propagate(); // Do lazy updates to children
        if (l <= minPos && maxPos <= r) {
            return min;
        } else if (r <= minPos || l >= maxPos) {
            return INF;
        }
        return Math.min(
                (left == null ? INF : left.min(l, r)),
                (right == null ? INF : right.min(l, r))
        );
    }
    // Does required updates, then lazily updates its children
    // NOTE: This method must be called before updating or accessing a node
    public void propagate() {
        if (lazy != 0) {
            min += lazy;
            if (left != null) {
                left.lazy += lazy;
            }
            if (right != null) {
                right.lazy += lazy;
            }
            lazy = 0;
        }
    }
}