#include <bits/stdc++.h>

typedef long long s64;

const int N = 200100;
const s64 sup = 1000000000000000000;

int n, k, m, c, d;
int a[N];

namespace SGT {
    const int pond = 20001000;

    int nClock, root[N];
    struct node {
        int lc, rc;
        int cnt;
    } t[pond];

    void insert(int &p, int q, s64 l, s64 r, s64 x) {
        p = ++ nClock, t[p] = t[q];
        t[p].cnt ++;
        if (l == r) return;
        s64 mid = (l + r) >> 1;
        if (x <= mid)
            insert(t[p].lc, t[q].lc, l, mid, x);
        else
            insert(t[p].rc, t[q].rc, mid + 1, r, x);
    }

    int ask(int p, int q, s64 l, s64 r, s64 s, s64 e) {
        if (s <= l && r <= e) return t[q].cnt - t[p].cnt;
        s64 mid = (l + r) >> 1;
        int cnt = 0;
        if (s <= mid)
            cnt += ask(t[p].lc, t[q].lc, l, mid, s, e);
        if (mid < e)
            cnt += ask(t[p].rc, t[q].rc, mid + 1, r, s, e);
        return cnt;
    }
}

int pre[N], suf[N];

bool check(s64 mid) {
    pre[0] = 0;
    for (int i = 1; i <= n; i ++) pre[i] = pre[i - 1] + (a[i] >= mid);

    suf[n + 1] = 0;
    for (int i = n; i >= 1; i --) suf[i] = suf[i + 1] + (a[i] >= mid);

    for (int x = 1; x <= n - m + 1; x ++) {
        int l = x, r = x + m - 1;
        int cnt = pre[l - 1] + suf[r + 1] + SGT::ask(SGT::root[l - 1], SGT::root[r], 0, sup, mid + 1ll * x * d - c, sup);

        if (cnt >= k) return 1;
    }

    return 0;
}

int main() {
    scanf("%d%d%d%d%d", &n, &k, &m, &c, &d);

    for (int i = 1; i <= n; i ++)
        scanf("%d", &a[i]);
    
    for (int i = 1; i <= n; i ++)
        SGT::insert(SGT::root[i], SGT::root[i - 1], 0, sup, a[i] + 1ll * i * d);

    s64 l = 0, r = 1000000000000000;
    while (l < r) {
        s64 mid = (l + r + 1) >> 1;
        if (check(mid)) l = mid; else r = mid - 1;
    }

    printf("%lld\n", l);

    return 0;
}