#include <bits/stdc++.h>
using namespace std;

// Function to compute the minimum number of flights to pay for
long long min_paid_flights(int n, int m, long long k, const vector<long long> &flights) {
    // Total padding at the start and end
    int padding = m - 1;
    // Create a padded flight list with m-1 zeros at both ends
    vector<long long> f_padded;
    f_padded.assign(padding, 0); // Padding at the start
    f_padded.insert(f_padded.end(), flights.begin(), flights.end()); // Original flights
    f_padded.insert(f_padded.end(), padding, 0); // Padding at the end

    int n_padded = f_padded.size();

    // Compute prefix sums of flights
    vector<long long> prefix_flights(n_padded + 1, 0);
    for(int i = 0; i < n_padded; ++i){
        prefix_flights[i + 1] = prefix_flights[i] + f_padded[i];
    }

    // Initialize an array to track paid flights in each month
    vector<long long> paid_flights(n_padded, 0);

    long long total_paid = 0;
    long long current_paid_in_window = 0;

    // Iterate through each possible window
    for(int i = 0; i <= n_padded - m; ++i){
        // Update the current number of paid flights in the window
        if(i > 0){
            current_paid_in_window -= paid_flights[i -1];
        }
        current_paid_in_window += paid_flights[i + m -1];

        // Total flights in the current window
        long long total_flights = prefix_flights[i + m] - prefix_flights[i];

        // Determine how many more flights need to be paid in this window
        long long need_to_pay;
        if(total_flights >= k){
            need_to_pay = max((long long)k - current_paid_in_window, (long long)0);
        }
        else{
            need_to_pay = max(total_flights - current_paid_in_window, (long long)0);
        }

        // If additional payments are needed, pay in the latest possible months within the window
        if(need_to_pay > 0){
            // Start from the last month in the window and move backwards
            int j = i + m -1;
            while(need_to_pay > 0 && j >= i){
                // Calculate how many flights can be paid in month j
                long long available = f_padded[j] - paid_flights[j];
                if(available > 0){
                    // Pay as many as possible in this month, up to the need
                    long long pay_now = min(need_to_pay, available);
                    paid_flights[j] += pay_now;
                    current_paid_in_window += pay_now;
                    total_paid += pay_now;
                    need_to_pay -= pay_now;
                }
                j--;
            }
            // It's guaranteed by problem constraints that a solution exists
        }
    }

    return total_paid;
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n, m;
    long long k;
    cin >> n >> m >> k;
    vector<long long> flights(n);
    for(int i =0; i <n; ++i){
        cin >> flights[i];
    }
    long long result = min_paid_flights(n, m, k, flights);
    cout << result;
    return 0;
}