def min_swaps(s, k):
    k_count = s.count(k)
    if k_count <= 1:
        return 0

    window_size = k_count
    non_k_count = 0
    
    for i in range(window_size):
        if s[i] != k:
            non_k_count += 1
    
    min_swaps = non_k_count
    
    for i in range(window_size, len(s)):
        if s[i - window_size] != k:
            non_k_count -= 1
        if s[i] != k:
            non_k_count += 1
        min_swaps = min(min_swaps, non_k_count)
    
    return min_swaps

from collections import Counter
def solve(s1, s2, s3):
    if Counter(s1) == Counter(s2) == Counter(s3):
        return "YES"
    else:
        return "NO"

def max_errors_in_window(N, error_counts, K):
    if K > N:
        return max(error_counts)

    window_sum = sum(error_counts[:K])
    max_errors = window_sum
    
    for i in range(K, N):
        window_sum = window_sum - error_counts[i-K] + error_counts[i]
        max_errors = max(max_errors, window_sum)
    
    return max_errors

N = int(input())
error_counts = [int(input()) for _ in range(N)]
K = int(input())

result = max_errors_in_window(N, error_counts, K)
print(result)

def find_index_pairs(arr, k):
    n = len(arr)
    result = [0] * n
    value_dict = {}

    for i, value in enumerate(arr):
        if value in value_dict:
            if abs(i - value_dict[value]) == k:
                result[i] = 1
                result[value_dict[value]] = 1
        value_dict[value] = i

        target_plus = value + k
        target_minus = value - k
        if target_plus in value_dict and abs(i - value_dict[target_plus]) == k:
            result[i] = 1
            result[value_dict[target_plus]] = 1
        if target_minus in value_dict and abs(i - value_dict[target_minus]) == k:
            result[i] = 1
            result[value_dict[target_minus]] = 1

    return result

N = int(input())
arr = [int(input()) for _ in range(N)]
K = int(input())

output = find_index_pairs(arr, K)
for val in output:
    print(val)

#include <iostream>
#include <string>
#include <deque>
using namespace std;
int main() {
    string chocolates, choices;
    cin >> chocolates;
    cin >> choices;
    deque<char> stack(chocolates.begin(), chocolates.end());
    int redCount = 0;
    for (char choice : choices) {
        if (choice == 'F') {
            if (stack.front() == 'R') {
                redCount++;
            }
            stack.pop_front();
        } else if (choice == 'L') {
            if (stack.back() == 'R') {
                redCount++;
            }
            stack.pop_back();
        }
    }
    cout << redCount << endl;
    return 0;
}