// Original C++ solution (slower):
#include <bits/stdc++.h>

 

using namespace std;

 

typedef long long int64;

 

const int64 INF = 1LL << 58;

 

template< typename T >

struct SegmentTree

{

  const T INF;

 

  vector< T > seg;

  int sz;

 

  SegmentTree(int n) : INF(numeric_limits< T >::max() / 10)

  {

    sz = 1;

    while(sz < n) sz <<= 1;

    seg.assign(2 * sz - 1, INF);

  }

 

  T merge(T a, T b)

  {

    return (min(a, b));

  }

 

  void set(int k, int x)

  {

    seg[k + sz - 1] = x;

  }

 

  void build()

  {

    for(int k = sz - 2; k >= 0; k--) {

      seg[k] = merge(seg[2 * k + 1], seg[2 * k + 2]);

    }

  }

 

  T rmq(int a, int b, int k, int l, int r)

  {

    if(a >= r || b <= l) return (INF);

    if(a <= l && r <= b) return (seg[k]);

    return (merge(rmq(a, b, 2 * k + 1, l, (l + r) >> 1),

                  rmq(a, b, 2 * k + 2, (l + r) >> 1, r)));

  }

 

  T rmq(int a, int b)

  {

    return (rmq(a, b, 0, 0, sz));

  }

 

  void update(int k, T x)

  {

    k += sz - 1;

    seg[k] = x;

    while(k > 0) {

      k = (k - 1) >> 1;

      seg[k] = merge(seg[2 * k + 1], seg[2 * k + 2]);

    }

  }

};

 

 

int main()

{

  int64 N, T, E, X[200002];

 

  cin >> N >> T >> E;

  for(int i = 1; i <= N; i++) cin >> X[i];

 

  /*

  int64 dp[2002][2002]; // curr, pending

  fill_n(*dp, 2002 * 2002, INF);

  dp[1][0] = 0;

  dp[1][1] = E;

*/

  auto chmin = [](int64 &a, int64 b)

  {

    a = min(a, b);

  };

 

  /*

  for(int i = 2; i <= N; i++) {

    for(int j = 0; j < i; j++) {

      chmin(dp[i][j], dp[i - 1][j]);

      chmin(dp[i][i], dp[i - 1][j] + max(E, (X[i] - X[j + 1]) * 2));

    }

  }

  // dp[j]+(X[i]-X[j+1])*2 = dp[j]+X[i]*2-X[j+1]*2

   // dp2[j]=dp[j]-X[j+1]*2

  */

 

 

  int64 dp[200002];

  fill_n(dp, 200002, INF);

  SegmentTree< int64 > dp2(N + 1);

 

  dp[0] = 0;

  dp[1] = E;

  dp2.update(0, dp[0] - X[1] * 2);

  dp2.update(1, dp[1] - X[2] * 2);

 

  for(int i = 2; i <= N; i++) {

    int low = 0, high = i - 1;

    while(high - low > 0) {

      int mid = (low + high) >> 1;

      if((X[i] - X[mid + 1]) * 2 <= E) high = mid;

      else low = mid + 1;

    }

/*

    cout << (X[i] - X[low + 1]) * 2 << " " << E << endl;

 

    for(int k = low; k < i; k++) cout << dp[k] << " ";

    cout << endl;

*/

    dp[i] = min(dp[low] + E, X[i] * 2 + dp2.rmq(0, low));

    //cout << low << endl;

    dp2.update(i, dp[i] - X[i + 1] * 2);

  }

  cout << dp[N] + T << endl;

}

// Optimized solution to the same problem (faster):
#include <bits/stdc++.h>



using namespace std;



#define rep(i, n) for(int64 i = 0; i < (int64)(n); i++)



using int64 = long long;

const int64 INF = 1LL << 60;



struct SegNode

{

  int64 v;



  SegNode(int64 v) : v(v) {}



  SegNode operator*(const SegNode &r) const

  {

    return (v < r.v ? *this : r);

  }

} e(INF);



struct SegmentTree

{

  int sz;

  vector< SegNode > seg;



  SegmentTree(int n)

  {

    sz = 1;

    while(sz < n) sz <<= 1;

    seg.assign(2 * sz - 1, e);

  }



  void update(int k, const SegNode &x)

  {

    k += sz - 1;

    seg[k] = x;

    while(k > 0) {

      k = (k - 1) >> 1;

      seg[k] = seg[2 * k + 1] * seg[2 * k + 2];

    }

  }



  SegNode query(int a, int b, int k, int l, int r)

  {

    if(a >= r || b <= l) return (e);

    if(a <= l && r <= b) return (seg[k]);

    return (query(a, b, 2 * k + 1, l, (l + r) >> 1) * query(a, b, 2 * k + 2, (l + r) >> 1, r));

  }



  SegNode query(int a, int b)

  {

    return (query(a, b, 0, 0, sz));

  }

};



int main()

{

  int64 N, E, T, X[100001] = {};



  cin >> N >> E >> T;

  for(int i = 0; i < N; i++) {

    cin >> X[i];

  }

  X[N] = E;



  vector< int64 > dp1(N + 1, INF);

  SegmentTree seg1(N + 1), seg2(N + 1);



  auto update = [&](int idx, int64 cost)

  {

    if(dp1[idx] > cost) {

      dp1[idx] = cost;

      seg1.update(idx, dp1[idx] - X[idx] + T);

      seg2.update(idx, dp1[idx] - 3 * X[idx]);

    }

  };

  update(0, X[0]);





  int ptr = 0;



  for(int i = 1; i <= N; i++) {



    while(ptr <= N && (X[i - 1] - X[ptr]) * 2 > T) {

      ++ptr;

    }



    update(i, min(seg1.query(ptr, i).v + X[i], seg2.query(0, ptr).v + X[i] + 2 * X[i - 1]));

  }



  cout << dp1.back() << endl;



}


// Fastest known solution for this problem: