#include <bits/stdc++.h>
using namespace std;
using II = long long;
II solve(vector<int> nums) {
    vector<int> Primes;
    for(int num = 2; num <= 200; num++) {
        bool isPrime = true;
        for(int factor = 2; factor * factor <= num; factor++) {
            if(num % factor == 0) {
                isPrime = false;
                break;
            }
        }
        if(isPrime) Primes.push_back(num);
    }
    map<II, II> mp;
    II ans = 0, mask = 0, one = 1;
    mp[mask] = 1;
    for(int num : nums) {
        for(int pos = 0; pos < Primes.size(); pos++) {
            int power = 0;
            while(num % Primes[pos] == 0) {
                num /= Primes[pos];
                power++;
            }
            if(power & 1) mask ^= (one << pos); 
        }
        ans += mp[mask]++;
    }
    return ans;
}

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)