Wilbur the pig really wants to be a beaver, so he decided today to pretend he is a beaver and bite at trees to cut them down.

There are n trees located at various positions on a line. Tree i is located at position xi. All the given positions of the trees are distinct.

The trees are equal, i.e. each tree has height h. Due to the wind, when a tree is cut down, it either falls left with probability p, or falls right with probability 1 - p. If a tree hits another tree while falling, that tree will fall in the same direction as the tree that hit it. A tree can hit another tree only if the distance between them is strictly less than h. 

For example, imagine there are 4 trees located at positions 1, 3, 5 and 8, while h = 3 and the tree at position 1 falls right. It hits the tree at position 3 and it starts to fall too. In it's turn it hits the tree at position 5 and it also starts to fall. The distance between 8 and 5 is exactly 3, so the tree at position 8 will not fall.

As long as there are still trees standing, Wilbur will select either the leftmost standing tree with probability 0.5 or the rightmost standing tree with probability 0.5. Selected tree is then cut down. If there is only one tree remaining, Wilbur always selects it. As the ground is covered with grass, Wilbur wants to know the expected total length of the ground covered with fallen trees after he cuts them all down because he is concerned about his grass-eating cow friends. Please help Wilbur.

Input

The first line of the input contains two integers, n (1 ≤ n ≤ 2000) and h (1 ≤ h ≤ 108) and a real number p (0 ≤ p ≤ 1), given with no more than six decimal places.

The second line of the input contains n integers, x1, x2, ..., xn ( - 108 ≤ xi ≤ 108) in no particular order.

Output

Print a single real number — the expected total length of the ground covered by trees when they have all fallen down. Your answer will be considered correct if its absolute or relative error does not exceed 10 - 6. 

Namely: let's assume that your answer is a, and the answer of the jury is b. The checker program will consider your answer correct, if <image>.

Examples

Input

2 2 0.500000
1 2


Output

3.250000000


Input

4 3 0.4
4 3 1 2


Output

6.631200000

Note

Consider the first example, we have 2 trees with height 2. 

<image> There are 3 scenarios: 

1. Both trees falls left. This can either happen with the right tree falling left first, which has <image> probability (also knocking down the left tree), or the left tree can fall left and then the right tree can fall left, which has <image> probability. Total probability is <image>. 

2. Both trees fall right. This is analogous to (1), so the probability of this happening is <image>. 

3. The left tree fall left and the right tree falls right. This is the only remaining scenario so it must have <image> probability. 

Cases 1 and 2 lead to a total of 3 units of ground covered, while case 3 leads to a total of 4 units of ground covered. Thus, the expected value is <image>.
#include <bits/stdc++.h>
using namespace std;
int n, i, j, l[2002], r[2002];
long double p, h, x[2002];
bool mark[2002][2002][2][2];
long double dp[2002][2002][2][2], z = 0.5;
void rec(int s, int e, int f1, int f2) {
  if (mark[s][e][f1][f2]) return;
  long double answ = 0;
  mark[s][e][f1][f2] = true;
  rec(s + 1, e, 0, f2);
  if (f1 == 0)
    answ += z * p * (min(h, x[s] - x[s - 1]) + dp[s + 1][e][0][f2]);
  else
    answ += z * p * (min(h, x[s] - x[s - 1] - h) + dp[s + 1][e][0][f2]);
  rec(s, e - 1, f1, 0);
  if (f2 == 0)
    answ += z * (1 - p) * (min(h, x[e + 1] - x[e]) + dp[s][e - 1][f1][0]);
  else
    answ += z * (1 - p) * (min(h, x[e + 1] - x[e] - h) + dp[s][e - 1][f1][0]);
  if (r[s] > e)
    answ += z * (1 - p) * (x[e] - x[s] + min(h, x[e + 1] - x[e] - f2 * h));
  else {
    rec(r[s], e, 1, f2);
    answ += z * (1 - p) * (x[r[s] - 1] - x[s] + h + dp[r[s]][e][1][f2]);
  }
  if (l[e] < s)
    answ += z * p * (x[e] - x[s] + min(h, x[s] - x[s - 1] - f1 * h));
  else {
    rec(s, l[e], f1, 1);
    answ += z * p * (x[e] - x[l[e] + 1] + h + dp[s][l[e]][f1][1]);
  }
  dp[s][e][f1][f2] = answ;
}
int main() {
  cout.setf(ios::fixed);
  cout.precision(8);
  cin >> n >> h >> p;
  for (i = 1; i <= n; i++) {
    cin >> x[i];
  }
  if (n == 1) {
    cout << h << endl;
    return 0;
  }
  sort(x + 1, x + n + 1);
  x[0] = -1000000000.0;
  x[n + 1] = 1000000000.0;
  for (i = 1; i <= n; i++) {
    dp[i][i][0][0] =
        p * (min(h, x[i] - x[i - 1])) + (1 - p) * (min(h, x[i + 1] - x[i]));
    dp[i][i][1][1] = p * (min(h, x[i] - x[i - 1] - h)) +
                     (1 - p) * (min(h, x[i + 1] - x[i] - h));
    dp[i][i][0][1] =
        p * (min(h, x[i] - x[i - 1])) + (1 - p) * (min(h, x[i + 1] - x[i] - h));
    dp[i][i][1][0] =
        p * (min(h, x[i] - x[i - 1] - h)) + (1 - p) * (min(h, x[i + 1] - x[i]));
    mark[i][i][0][0] = true;
    mark[i][i][1][1] = true;
    mark[i][i][0][1] = true;
    mark[i][i][1][0] = true;
  }
  for (i = 1; i <= n; i++) {
    j = i + 1;
    while (j <= n && x[j] - x[j - 1] < h) j++;
    r[i] = j;
  }
  for (i = n; i >= 1; i--) {
    j = i - 1;
    while (j >= 1 && x[j + 1] - x[j] < h) j--;
    l[i] = j;
  }
  mark[0][0][0][0] = true;
  mark[0][0][1][1] = true;
  mark[0][0][0][1] = true;
  mark[0][0][1][0] = true;
  mark[n + 1][n + 1][0][0] = true;
  mark[n + 1][n + 1][1][1] = true;
  mark[n + 1][n + 1][0][1] = true;
  mark[n + 1][n + 1][1][0] = true;
  rec(1, n, 0, 0);
  cout << dp[1][n][0][0] << endl;
  return 0;
}
