#define ENABLE_DEBUG 1
// Kana's kitchen {{{
#include<bits/stdc++.h>
#define ALL(v) std::begin(v), std::end(v)
#define REP(i, k) for (decltype(k) i = 0; i < k; i++)
#define LOOP(k) REP (ngtkana_is_a_genius, k)

using i32 = std::int_least32_t;
using i64 = std::int_least64_t;
using u32 = std::uint_least32_t;
using u64 = std::uint_least64_t;
using usize = std::size_t;

template <class T, class U> using pair = std::pair<U, T>;
template <class T> using diag_pair = std::pair<T, T>;
template <class... Args> using tuple = std::tuple<Args...>;
template <class T> using vec = std::vector<T>;
template <class T> using numr = std::numeric_limits<T>;

#ifdef NGTKANA
#include<debug.hpp>
#else
#define DEBUG(...)(void)0
#endif
/*}}}*/
// segtree{{{
template <class Monoid>
struct segtree {
    using value_type = typename Monoid::value_type;

    std::vector<value_type> table;

    segtree()=default;
    segtree(segtree const&)=default;
    segtree(segtree&&)=default;
    segtree&operator=(segtree const&)=default;
    segtree&operator=(segtree&&)=default;

    segtree(std::size_t n, value_type init=Monoid::id())
        : table(2*n, init) {}

    void resize(std::size_t n, value_type init=Monoid::id()) {
        assert(table.empty());
        table.resize(2*n, init);
    }

    void lazy_set(std::size_t i, value_type x) {
        table.at(i + size()) = x;
    }

    void build() {
        for (std::size_t i=size()-1; i; i--) {
            table.at(i) = Monoid::op(table.at(2*i), table.at(2*i+1));
        }
    }

    std::size_t size() const { return table.size() / 2; }

    value_type fold(std::size_t l, std::size_t r) const {
        value_type fl = Monoid::id();
        value_type fr = Monoid::id();

        for(l+=size(),r+=size();l<r;l>>=1,r>>=1){
            if(l&1u) fl=Monoid::op(fl, table.at(l++));
            if(r&1u) fr=Monoid::op(fr, table.at(--r));
        }

        return Monoid::op(fl, fr);
    }

    value_type get(std::size_t i) const { return table.at(size() + i); }

    std::vector<value_type> to_vec() const {
        std::vector<value_type> ret(size());
        std::copy(table.begin()+size(), table.end(), ret.begin());
        return ret;
    }

    void set(std::size_t i, value_type x) {
        assert(i < size());
        i+=size();
        table.at(i) = x;
        for (i>>=1; i; i>>=1) {
            table.at(i) = Monoid::op(table.at(2*i), table.at(2*i+1));
        }
    }

    void add(std::size_t i, value_type x) { set(i, get(i) + x); }
    void sub(std::size_t i, value_type x) { set(i, get(i) - x); }
    void mul(std::size_t i, value_type x) { set(i, get(i) * x); }
    void div(std::size_t i, value_type x) { set(i, get(i) / x); }
    void cmn(std::size_t i, value_type x) { set(i, std::min(get(i), x)); }
    void cmx(std::size_t i, value_type x) { set(i, std::max(get(i), x)); }

    template <class F> void map(std::size_t i, F const& f) { set(i, f(get(i))); }
};
/*}}}*/
template <class Value> struct min_monoid_t {
    using value_type = Value;
    static value_type op(value_type l, value_type r) { return std::min(l, r); }
    static const value_type id() { return std::numeric_limits<Value>::max(); }
};
auto cmn = [](auto& x, auto y){ if (x>y) { x=y; return true; } return false; };
int main() {
    std::cin.tie(nullptr);
    std::ios::sync_with_stdio(false);
    std::cout << std::setprecision(15) << std::fixed;

    usize n; i64 E, T; std::cin >> n >> E >> T;
    vec<i64> a(n+1);
    for (usize i=1; i<=n; i++) std::cin >> a.at(i);

    auto dp = segtree<min_monoid_t<i64>>(n+1);
    auto ep = segtree<min_monoid_t<i64>>(n+1);
    dp.set(0, 0);
    ep.set(0, -2 * a.at(1));
    for (usize l=0, j=1; j<=n; j++) {
        for (; T < 2 * (a.at(j) - a.at(l+1)); l++);
        if (l) dp.cmn(j, ep.fold(0, l) + 2 * a.at(j));
        dp.cmn(j, dp.fold(l, j) + T);
        if (j < n) ep.set(j, dp.get(j) - 2 * a.at(j + 1));
    }

    i64 ans = dp.get(n) + E;
    std::cout << ans << '\n';
}


Measured memory_bytes: 4224