#include <bits/stdc++.h>
using namespace std;

typedef long long ll;

template <typename T, bool isInc = true, bool isMin = true>
struct ConvexHullTrickAddMonotone {
    using P = pair<T, T>;
    deque<P> H;

    bool empty() const { return H.empty(); }

    void clear() { H.clear(); }

    inline int sgn(T x) { return x == 0 ? 0 : (x < 0 ? -1 : 1); }

    using D = long double;

    inline bool check(const P &a, const P &b, const P &c) {
        if (b.second == a.second || c.second == b.second)
            return sgn(b.first - a.first) * sgn(c.second - b.second) >=
                   sgn(c.first - b.first) * sgn(b.second - a.second);
        return D(b.first - a.first) * sgn(c.second - b.second) /
                   D(abs(b.second - a.second)) >=
               D(c.first - b.first) * sgn(b.second - a.second) /
                   D(abs(c.second - b.second));
    }

    void add(T a, T b) {
        if (!isMin) a *= -1, b *= -1;
        P line(a, b);
        if (empty()) {
            H.emplace_front(line);
            return;
        }
        if (isInc ^ (!isMin)) {  // 傾きが単調増加
            if (H.front().first == a) {
                if (H.front().second <= b) return;
                H.pop_front();
            }
            while (H.size() >= 2 && check(line, H.front(), H[1])) H.pop_front();
            H.emplace_front(line);
        } else {  // 傾きが単調減少
            if (H.back().first == a) {
                if (H.back().second <= b) return;
                H.pop_back();
            }
            while (H.size() >= 2 && check(H[H.size() - 2], H.back(), line))
                H.pop_back();
            H.emplace_back(line);
        }
    }

    inline T get_y(const P &a, const T &x) { return a.first * x + a.second; }

    T query(T x) {
        int l = -1, r = H.size() - 1;
        while ((r - l) > 1) {
            int m = (l + r) / 2;
            if (get_y(H[m], x) >= get_y(H[m + 1], x))
                l = m;
            else
                r = m;
        }
        if (isMin) return get_y(H[r], x);
        return -get_y(H[r], x);
    }

    T query_monotone_inc(T x) {
        while (H.size() >= 2 && get_y(H.front(), x) >= get_y(H[1], x))
            H.pop_front();
        if (isMin)
            return get_y(H.front(), x);
        else
            return -get_y(H.front(), x);
    }

    T query_monotone_dec(T x) {
        while (H.size() >= 2 && get_y(H.back(), x) >= get_y(H[H.size() - 2], x))
            H.pop_back();
        if (isMin)
            return get_y(H.back(), x);
        else
            return -get_y(H.back(), x);
    }
};

int main() {
    int N;
    ll A, B, W;
    cin >> N >> A >> B >> W;
    vector<ll> D(N + 1);
    for (int i = 1; i <= N; i++) cin >> D[i];
    vector<ll> dp(N + 1);
    ConvexHullTrickAddMonotone<ll, false, true> cht;
    cht.add(0, 0);
    for (int i = 1; i <= N; i++) {
        dp[i] = cht.query_monotone_inc(i) - A * (i - 1) + (i * i - i) / 2 * B +
                D[i];
        cht.add(-i * B, dp[i] + A * i + (i * i + i) / 2 * B);
    }
    ll ans = 1LL << 60;
    for (int i = 0; i <= N; i++) {
        ans = min(ans, dp[i] - A * (N - i) + (N - i) * (N - i + 1) / 2 * B + W);
    }
    cout << ans << endl;
}