#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>

using namespace std;

int maxResource(const vector<int>& nums, int k) {
    int n = nums.size();
    if (n == 0 || k <= 0 || k > n) {
        return 0;
    }
    
    long long currentSum = 0;
    for (int i = 0; i < k; ++i) {
        currentSum += nums[i];
    }
    
    long long maxSum = currentSum;
    
    for (int i = k; i < n; ++i) {
        currentSum += nums[i] - nums[i - k];
        maxSum = max(maxSum, currentSum);
    }
    
    return static_cast<int>(maxSum);
}

int main() {
    int n;
    if (!(cin >> n)) return 0;
    
    vector<int> nums(n);
    for (int i = 0; i < n; ++i) {
        cin >> nums[i];
    }
    
    int k;
    cin >> k;
    
    cout << maxResource(nums, k) << endl;
    
    return 0;
}

import java.util.*;
import java.io.*;

public class Main {
    public static int maxResource(int[] nums, int k) {
        int n = nums.length;
        if (n == 0 || k <= 0 || k > n) {
            return 0;
        }
        
        long currentSum = 0;
        for (int i = 0; i < k; i++) {
            currentSum += nums[i];
        }
        
        long maxSum = currentSum;
        
        for (int i = k; i < n; i++) {
            currentSum += nums[i] - nums[i - k];
            if (currentSum > maxSum) {
                maxSum = currentSum;
            }
        }
        
        return (int) maxSum;
    }
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        
        int n = Integer.parseInt(br.readLine().trim());
        int[] nums = new int[n];
        
        String[] parts = br.readLine().trim().split("\\s+");
        for (int i = 0; i < n; i++) {
            nums[i] = Integer.parseInt(parts[i]);
        }
        
        int k = Integer.parseInt(br.readLine().trim());
        
        System.out.println(maxResource(nums, k));
    }
}

def max_resource(nums, k):
    """
    Compute the maximum total resource collected over any contiguous segment of length k.
    
    Args:
        nums (list[int]): List of integers representing daily resources.
        k (int): The exact number of consecutive days.
    
    Returns:
        int: The maximum total resource collected.
    """
    n = len(nums)
    if n == 0 or k <= 0 or k > n:
        return 0
    
    current_sum = sum(nums[:k])
    max_sum = current_sum
    
    for i in range(k, n):
        current_sum += nums[i] - nums[i - k]
        if current_sum > max_sum:
            max_sum = current_sum
    
    return max_sum

if __name__ == "__main__":
    import sys
    data = sys.stdin.read().split()
    if not data:
        sys.exit(0)
    
    n = int(data[0])
    nums = list(map(int, data[1:1+n]))
    k = int(data[1+n])
    
    print(max_resource(nums, k))

/**
 * @param {number[]} nums - Array of integers representing daily resources.
 * @param {number} k - The exact number of consecutive days.
 * @return {number} The maximum total resource collected over any contiguous segment of length k.
 */
function maxResource(nums, k) {
    const n = nums.length;
    if (n === 0 || k <= 0 || k > n) {
        return 0;
    }
    
    let currentSum = 0;
    for (let i = 0; i < k; i++) {
        currentSum += nums[i];
    }
    
    let maxSum = currentSum;
    
    for (let i = k; i < n; i++) {
        currentSum += nums[i] - nums[i - k];
        if (currentSum > maxSum) {
            maxSum = currentSum;
        }
    }
    
    return maxSum;
}

// Driver code
const readline = require('readline');

const rl = readline.createInterface({
    input: process.stdin,
    terminal: false
});

let lines = [];
rl.on('line', line => {
    lines.push(line);
});

rl.on('close', () => {
    const input = lines.join(' ').split(' ').map(Number);
    const n = input[0];
    const nums = input.slice(1, 1 + n);
    const k = input[1 + n];
    
    console.log(maxResource(nums, k));
});