#include <bits/stdc++.h>
struct val {
    long long x;
    int l, r;
    val operator + (const val &rhs) const { return (val){x + rhs.x, l, rhs.r}; }
    bool operator < (const val &rhs) const { return x < rhs.x; }
};
struct Seq {
    val sum, lmax, rmax, max;
    Seq operator + (const Seq &rhs) const {
        return (Seq){
            sum + rhs.sum,
            std::max(lmax, sum + rhs.lmax),
            std::max(rhs.rmax, rmax + rhs.sum),
            std::max({max, rhs.max, rmax + rhs.lmax})
        };
    }
};
struct Node {
    Node *ls, *rs;
    bool tag;
    Seq seq, nseq;
    void up() {
        assert(ls && rs);
        seq = ls->seq + rs->seq;
        nseq = ls->nseq + rs->nseq;
    }
    void flip() {
        std::swap(seq, nseq);
        tag ^= 1;
    }
    void pushdown() {
        if (tag) {
            ls->flip(), rs->flip();
            tag = 0;
        }
    }
};
int main() {
    int n;
    long long k;
    scanf("%d", &n);
    std::vector <int> a(n + 1);
    for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
    scanf("%lld", &k);
    std::vector <Node> arr(n * 2 + 5);
    arr.clear();
    Node *rt;
    auto build = [&](auto &&build, Node *&u, int l, int r) {
        arr.emplace_back();
        u = &arr.back();
        if (l == r) {
            u->seq.sum = u->seq.max = u->seq.rmax = u->seq.lmax = {a[l], l, l};
            u->nseq.sum = u->nseq.max = u->nseq.rmax = u->nseq.lmax = {-a[l], l, l};
            return;
        }
        int mid = (l + r) / 2;
        build(build, u->ls, l, mid);
        build(build, u->rs, mid + 1, r);
        u->up();
    };
    build(build, rt, 1, n);
    long long w = 0;
    std::vector <std::pair <int, long long>> strl;
    strl.emplace_back(0, 0);
    auto append = [&](int k, long long b) {
        // printf("%d %lld\n", k, b);
        while (strl.size() > 1) {
            auto [k1, b1] = strl.back();
            auto [k2, b2] = strl[strl.size() - 2];
            long double x = (long double)(b1 - b2) / (k1 - k2);
            if (x * k - b <= x * k1 - b1) strl.pop_back();
            else break;
        }
        strl.emplace_back(k, b);
    };
    for (int i = 1; i <= n; ++i) {
        if (rt->seq.max.x <= 0) break;
        w += rt->seq.max.x;
        append(i, w);
        auto upd = [&](auto &&upd, Node *u, int tl, int tr, int l, int r) {
            if (tl <= l && r <= tr) return u->flip();
            u->pushdown();
            int mid = (l + r) / 2;
            if (tl <= mid) upd(upd, u->ls, tl, tr, l, mid);
            if (tr > mid) upd(upd, u->rs, tl, tr, mid + 1, r);
            u->up();
        };
        upd(upd, rt, rt->seq.max.l, rt->seq.max.r, 1, n);
    }
    std::sort(a.begin(), a.end(), std::greater <int>());
    for (int i = strl.back().first + 1; i <= n; ++i) if (a[i] <= 0) {
        w += a[i];
        append(i, w);
    }
    // if (strl.back().first == 0) strl.emplace_back(1, 0);
    assert(strl.back().first != 0);
    long long L = ceil((long double)(strl.back().second - k) / strl.back().first);
    int ans = 0;
    const int mod = 998244353;
    bool lef = 0;
    while (strl.size() > 1) {
        auto [k1, b1] = strl.back();
        strl.pop_back();
        auto [k2, b2] = strl.back();
        long double x = (long double)(b1 - b2) / (k1 - k2);
        // printf("%lld %llf\n", L, x);
        if (x < L) {
            L = ceil((long double)(b2 - k) / k2);
            continue;
        }
        long long R = ceil(x);
        if (L < R) {
            if (lef == 0) {
                ans = (k + (k1 * L - b1)) % mod * L % mod;
                lef = 1;
            }
            ans = (ans + (__int128)(R + L + 1) * (R - L) / 2 % mod * k1 - R + L) % mod;
        }
        L = R;
    }
    printf("%d\n", ans < 0? ans + mod: ans);
}