#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <sstream>
#include <complex>
#include <ctime>
#include <cassert>
#include <functional>

using namespace std;

typedef long long ll;
typedef vector<int> VI;
typedef pair<int,int> PII;

#define REP(i,s,t) for(int i=(s);i<(t);i++)
#define FILL(x,v) memset(x,v,sizeof(x))

const ll INF = (ll)1e18;
const int SmallInf = (int)1e9;
#define MAXN 200005

bool v[MAXN];
ll arr[MAXN*2];
bool checkOk(int j, vector<PII> &oks) {
  if (oks.empty()) return false;
  int l = 0, r = (int)oks.size() - 1;
  while (l <= r) {
    int m = (l + r) / 2;
    if (oks[m].first > j) r = m - 1;
    else l = m + 1;
  }
  int idx = r;
  return idx >= 0 && idx < oks.size() && j <= oks[idx].second;
}
int main() {
  int n, k, d, s;
  cin >> n >> k >> d >> s;
  REP(i,0,n) cin >> arr[i];
  REP(i,n,2*n) arr[i] = arr[i - n];
  REP(i,0,2*n) arr[i] += arr[i - 1];
  ll ans = -INF;
  REP(i,0,n-s+1) {
    if (v[i]) continue;
    vector<ll> cyc, pcyc;
    vector<PII> oks;
    int j = i;
    while (!v[j]) {
      ll cur = arr[j + s - 1] - (j - 1 < 0 ? 0 : arr[j - 1]);
      cyc.push_back(cur);
      if (j + s <= n) {
        int t = (int)cyc.size() - 1;
        if (oks.size() && oks.back().second >= t + d - 1) oks.back().second = t + n - 1;
        else oks.push_back(PII(t + d - 1, t + n - 1));
      }
      v[j] = true;
      j = (j + k) % n;
    }
    int C = cyc.size();
    pcyc.push_back(cyc[0]);
    REP(j,1,3*C) pcyc.push_back(pcyc.back() + cyc[j % C]);
    ll sumcyc = pcyc[C - 1];
    REP(j,d-1,3*C) {
      if (!checkOk(j, oks)) continue;
      ans = max(ans, pcyc[j] - (j - d < 0 ? 0 : pcyc[j - d]));
    }
    int maxOk = oks.back().second;
    REP(j,max(d-1,maxOk-3*C),maxOk+1) {
      if (!checkOk(j, oks)) continue;
      ll pcycj = sumcyc * (j / C) + pcyc[j % C];
      ll pcycjmd = j - d < 0 ? 0 : sumcyc * ((j - d) / C) + pcyc[(j - d) % C];
      ans = max(ans, pcycj - pcycjmd);
    }
  }
  cout << ans << endl;
  return 0;
}