#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long powmod(long long a, long long b) {
  long long res = 1;
  a %= mod;
  for (; b; b >>= 1) {
    if (b & 1) res = res * a % mod;
    a = a * a % mod;
  }
  return res;
}
int n, h;
double p;
vector<int> trees;
int coverage[2005][2];
double dp[2005][2005][2][2];
double getCovered(int l, int r, int dl, int dr) {
  if (l > r) return 0;
  double& ret = dp[l][r][dl][dr];
  if (ret) return ret;
  double ret1 = 0;
  int l1 = min(r, l + coverage[l][1] - 1);
  if (l1 == r) {
    if (dr == 0)
      ret1 +=
          (1 - p) * (min(h, trees[r + 1] - trees[r] - h) + trees[r] - trees[l]);
    else
      ret1 += (1 - p) * (min(h, trees[r + 1] - trees[r]) + trees[r] - trees[l]);
  } else {
    ret1 += (1 - p) * getCovered(l1 + 1, r, 1, dr);
    ret1 += (1 - p) * (trees[l1] - trees[l] + h);
  }
  if (dl == 1)
    ret1 += p * min(h, trees[l] - trees[l - 1] - h);
  else
    ret1 += p * min(h, trees[l] - trees[l - 1]);
  ret1 += p * getCovered(l + 1, r, 0, dr);
  int r1 = max(l, r - coverage[r][0] + 1);
  if (l == r1) {
    if (dl == 1)
      ret1 += p * (min(h, trees[l] - trees[l - 1] - h) + trees[r] - trees[l]);
    else
      ret1 += p * (min(h, trees[l] - trees[l - 1]) + trees[r] - trees[l]);
  } else {
    ret1 += p * getCovered(l, r1 - 1, dl, 0);
    ret1 += p * (trees[r] - trees[r1] + h);
  }
  if (dr == 0)
    ret1 += (1 - p) * min(h, trees[r + 1] - trees[r] - h);
  else
    ret1 += (1 - p) * min(h, trees[r + 1] - trees[r]);
  ret1 += (1 - p) * getCovered(l, r - 1, dl, 1);
  ret1 /= 2.;
  return ret = ret1;
}
int main() {
  cout.precision(12);
  memset(dp, 0, sizeof(dp));
  memset(coverage, 0, sizeof(coverage));
  cin >> n >> h >> p;
  n += 2;
  trees.resize(n);
  trees[n - 2] = 987654321;
  trees[n - 1] = -987654321;
  for (int i = 0; i < (int)n - 2; i++) cin >> trees[i];
  sort(trees.begin(), trees.end());
  coverage[0][0] = 1;
  for (int i = 1; i < (int)n; i++) {
    if (trees[i] - trees[i - 1] < h)
      coverage[i][0] = coverage[i - 1][0] + 1;
    else
      coverage[i][0] = 1;
  }
  coverage[n - 1][1] = 1;
  for (int i = n - 2; i >= 0; i--) {
    if (trees[i + 1] - trees[i] < h)
      coverage[i][1] = coverage[i + 1][1] + 1;
    else
      coverage[i][1] = 1;
  }
  cout << getCovered(1, n - 2, 0, 1) << endl;
  return 0;
}
