#include <bits/stdc++.h>
using namespace std;
namespace {
using Integer = long long;
template <class T, class S>
istream& operator>>(istream& is, pair<T, S>& p) {
  return is >> p.first >> p.second;
}
template <class T>
istream& operator>>(istream& is, vector<T>& vec) {
  for (T& val : vec) is >> val;
  return is;
}
template <class T>
istream& operator,(istream& is, T& val) {
  return is >> val;
}
template <class T, class S>
ostream& operator<<(ostream& os, const pair<T, S>& p) {
  return os << p.first << " " << p.second;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& vec) {
  for (size_t i = 0; i < vec.size(); i++)
    os << vec[i] << (i == vec.size() - 1 ? "" : " ");
  return os;
}
template <class T>
ostream& operator,(ostream& os, const T& val) {
  return os << " " << val;
}
template <class H>
void print(const H& head) {
  cout << head;
}
template <class H, class... T>
void print(const H& head, const T&... tail) {
  cout << head << " ";
  print(tail...);
}
template <class... T>
void println(const T&... values) {
  print(values...);
  cout << endl;
}
template <class H>
void eprint(const H& head) {
  cerr << head;
}
template <class H, class... T>
void eprint(const H& head, const T&... tail) {
  cerr << head << " ";
  eprint(tail...);
}
template <class... T>
void eprintln(const T&... values) {
  eprint(values...);
  cerr << endl;
}
class range {
  Integer start_, end_, step_;

 public:
  struct range_iterator {
    Integer val, step_;
    range_iterator(Integer v, Integer step) : val(v), step_(step) {}
    Integer operator*() { return val; }
    void operator++() { val += step_; }
    bool operator!=(range_iterator& x) {
      return step_ > 0 ? val < x.val : val > x.val;
    }
  };
  range(Integer len) : start_(0), end_(len), step_(1) {}
  range(Integer start, Integer end) : start_(start), end_(end), step_(1) {}
  range(Integer start, Integer end, Integer step)
      : start_(start), end_(end), step_(step) {}
  range_iterator begin() { return range_iterator(start_, step_); }
  range_iterator end() { return range_iterator(end_, step_); }
};
inline string operator"" _s(const char* str, size_t size) {
  return move(string(str));
}
constexpr Integer my_pow(Integer x, Integer k, Integer z = 1) {
  return k == 0    ? z
         : k == 1  ? z * x
         : (k & 1) ? my_pow(x * x, k >> 1, z * x)
                   : my_pow(x * x, k >> 1, z);
}
constexpr Integer my_pow_mod(Integer x, Integer k, Integer M, Integer z = 1) {
  return k == 0    ? z % M
         : k == 1  ? z * x % M
         : (k & 1) ? my_pow_mod(x * x % M, k >> 1, M, z * x % M)
                   : my_pow_mod(x * x % M, k >> 1, M, z);
}
constexpr unsigned long long operator"" _ten(unsigned long long value) {
  return my_pow(10, value);
}
inline int k_bit(Integer x, int k) { return (x >> k) & 1; }
mt19937 mt(chrono::duration_cast<chrono::nanoseconds>(
               chrono::steady_clock::now().time_since_epoch())
               .count());
template <class T>
string join(const vector<T>& v, const string& sep) {
  stringstream ss;
  for (size_t i = 0; i < v.size(); i++) {
    if (i > 0) ss << sep;
    ss << v[i];
  }
  return ss.str();
}
inline string operator*(string s, int k) {
  string ret;
  while (k) {
    if (k & 1) ret += s;
    s += s;
    k >>= 1;
  }
  return ret;
}
}  // namespace
constexpr long long mod = 9_ten + 7;
class starry_sky_tree {
 public:
  static const int MAX_SIZE = 1 << 17;
  using Int = long long;
  Int segMin[2 * MAX_SIZE - 1], segAdd[2 * MAX_SIZE - 1];
  starry_sky_tree() {
    fill(segMin, segMin + 2 * MAX_SIZE - 1, 0);
    fill(segAdd, segAdd + 2 * MAX_SIZE - 1, 0);
  }
  void add(int a, int b, Int x, int k = 0, int l = 0, int r = MAX_SIZE) {
    if (r <= a || b <= l) return;
    if (a <= l && r <= b) {
      segAdd[k] += x;
      return;
    }
    add(a, b, x, k * 2 + 1, l, (l + r) / 2);
    add(a, b, x, k * 2 + 2, (l + r) / 2, r);
    segMin[k] = min(segMin[k * 2 + 1] + segAdd[k * 2 + 1],
                    segMin[k * 2 + 2] + segAdd[k * 2 + 2]);
  }
  Int getMin(int a, int b, int k = 0, int l = 0, int r = MAX_SIZE) {
    if (r <= a || b <= l) return (LLONG_MAX);
    if (a <= l && r <= b) return (segMin[k] + segAdd[k]);
    Int left = getMin(a, b, k * 2 + 1, l, (l + r) / 2);
    Int right = getMin(a, b, k * 2 + 2, (l + r) / 2, r);
    return (min(left, right) + segAdd[k]);
  }
};
int main() {
  int n;
  long long e, t;
  cin >> n, e, t;
  vector<long long> x(n);
  cin >> x;
  x.push_back(e);
  x.push_back(1ll << 57);
  starry_sky_tree a, b;
  vector<long long> dp(n + 1, 1ll << 57);
  dp[0] = 0;
  for (int i = 0, j = 0; i < n; i++) {
    while (j < i && t < 2 * (x[i] - x[j])) {
      j++;
    }
    if (j) dp[i + 1] = min(dp[i + 1], a.getMin(0, j));
    dp[i + 1] = min(dp[i + 1], t + b.getMin(j, i + 1));
    a.add(0, i + 1, 2 * (x[i + 1] - x[i]));
    b.add(i + 1, i + 2, dp[i + 1]);
  }
  println(dp[n] + e);
  return 0;
}
