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;
}

#include <iostream>
#include <vector>
using namespace std;
using ll = long long;
int solve(int x, int n, vector<int>& a) {
    ll ans = 0;
    for (int num : a) {
        ans += num;
    }
    if (ans % x != 0) {
        return n;
    }
    ll left = 0, right = n - 1;
    while (left < n && a[left] % x == 0) {
        left++;
    }
    while (right >= 0 && a[right] % x == 0) {
        right--;
    }

    ll mm = max(n - left - 1, right);
    return mm > 0 ? mm : -1;
}

#include <bits/stdc++.h>
using namespace std;
#define ll long long
const ll N=1e5+10;
ll vis[N]={0},a[26]={0};
char col[N];
vector<ll>adj[N];
ll ans=0;
void dfs(ll node) 
{
    if(a[col[node]-'a']==0) ans++;
    a[col[node]-'a']++;
    vis[node]=1;
    for (ll it:adj[node]) 
    {
        if(!vis[it])
            dfs(it);
    }
    a[col[node]-'a']--;
}
signed main()
{   
    ll t; cin>>t;
    while(t--)
    {   
        ll n; cin>>n;
        for(ll i=1;i<=n;i++) 
        {
            adj[i].clear();
            vis[i]=0;
        }
        for(auto&it:a) it=0;
        for(ll i=1;i<=n;i++) cin>>col[i];
        for(ll i=0;i<n-1;i++)
        {
            ll u,v; cin>>u>>v;
            adj[u].push_back(v);
        adj[v].push_back(u);
        }  
        ans=0;
        dfs(1);
        cout<<ans<<endl;
    }    
}

#include <bits/stdc++.h>
using namespace std;
#define ll long long
const ll N=1e5+10;
class dsu 
{
public:
    vector<ll> parent,size;
    dsu(ll n) {
        parent.resize(n + 1);
        size.resize(n + 1,1);
        for (ll i = 0; i <= n; i++) parent[i] = i;
    }

    ll par(ll node) {
        if (node == parent[node])
            return node;
        return parent[node]=par(parent[node]);
    }
       void usize(ll u,ll v) {
        ll ulp_u=par(u);
        ll ulp_v=par(v);
        if (ulp_u == ulp_v) return;
        if (size[ulp_u] < size[ulp_v]) {
            parent[ulp_u] = ulp_v;
            size[ulp_v] += size[ulp_u];
        }
        else {
            parent[ulp_v] = ulp_u;
            size[ulp_u] += size[ulp_v];
        }
    }
};
bool prime[N]; 
void pre()
{
    memset(prime,true,sizeof(prime));
    prime[1]=0;
    for(ll i=2;i*i<=N;i++)
    {
        if(prime[i]==1)
        {
            for(ll j=i*i;j<=N;j+=i)
                prime[j]=0;
        }
   }
}
signed main()
{   
    pre();
    ll n; cin>>n;
    dsu obj(n+1);
   vector<vector<ll>>g(n+1);
   for(ll i=1;i<n;i++)
   {
    ll a,b; cin>>a>>b;
    if(prime[a]==1 && prime[b]==1) continue;
    else if(prime[a]==1) g[a].push_back(b);
    else if(prime[b]==1) g[b].push_back(a);
    else obj.usize(a,b);
   }
   ll ans=0;
   for(ll i=1;i<=n;i++)
   {
    if(prime[i])
    {
      ll curr=1;
      for(auto rel:g[i]) curr+=obj.size[obj.par(rel)];
      for(auto rel:g[i])
      {
        ll ex=obj.size[obj.par(rel)];
        ans+=ex*(curr-ex);
        curr-=ex;
      }
    }
   }
   cout<<ans<<endl;
}

SELECT order_id, product_id, buyer
FROM quantity
WHERE quantity_ordered = ANY (SELECT 6)
ORDER BY buyer ASC;

#include <bits/stdc++.h>
using namespace std;
#define ll long long
ll solve(vector<ll>&a)
{
    ll n=a.size();
    ll ans=0;
    unordered_map<ll,ll>mpp;
    for(auto it:a) mpp[it]++;
    ll i=3;
    vector<ll>t;
    while(i<=pow(3,21))
    {
        t.push_back(i);
        i*=3;
    }
    for(ll i=0;i<n;i++)
    {
        for(auto it:t)
        {
            if(it>=a[i] && mpp.find(it-a[i])!=mpp.end()) ans+=mpp[a[i]]*mpp[it-a[i]];
            
        }
        mpp.erase(a[i]);
    }
    return ans;
   
}
signed main()
{   
        ll n; cin>>n;
        vector<ll>a(n);
        for(ll i=0;i<n;i++) cin>>a[i];
        cout<<solve(a)<<endl;  
}