Problem: Esports is a form of competitive sports using video games. Dota 2 is one of the most popular competitive video games in Esports. Recently, a new video game Dota 3 was released. In Dota 3 a player can buy some relics for their hero. Relics are counters that track hero's actions and statistics in a game.

Gloria likes to play Dota 3, so she wants to buy all n available relics for her favorite hero.

Relics can be bought using an in-game currency called shards. Each relic has its own price — c_i shards for the i-th relic. A player can buy a relic using one of the following options: 

  * Pay c_i shards to buy the i-th relic; 
  * Pay x shards and randomly get one of all n relics. The probability of getting a relic is the same for all n relics. If a duplicate relic is received, then the relic is recycled and x/2 shards are given back to the player. 



Gloria wants to buy all n relics. Help her minimize the expected number of shards she spends to buy all the relics.

Input

The first line contains two integers n and x (1 ≤ n ≤ 100; 1 ≤ x ≤ 10 000) — the number of relics and the cost to receive a random relic.

The second line consists of n integers c_1, c_2, …, c_n (x ≤ c_i ≤ 10 000; ∑{c_i} ≤ 10 000) — the prices of n relics.

Output

Print a single real number — the minimum expected number of shards that Gloria must spend to buy all the relics.

The absolute or relative error should not exceed 10^{-9}.

Examples

Input


2 20
25 100


Output


47.50000000000000000


Input


4 30
60 50 60 80


Output


171.25000000000000000

Note

In the first example, the optimal strategy is to randomly get one of the two relics paying 20 shards. Then there are two scenarios. 

The first one happens if Gloria receives the first relic. Then she keeps getting random relics until she obtains the second relic. The expected number of shards to spend in this scenario is 20 + 30 = 50.

In the second scenario, Gloria initially gets the second relic. Then it is better to buy the first relic for 25 shards, so the expected number of shards to spend in this scenario is 20 + 25 = 45.

Thus, the expected number of shards to spend is (50 + 45)/(2) = 47.5.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
using ld = long double;
using u64 = long long;
u64 M = 1ll << 50;
struct u128 {
  u64 lo, hi;
  ld todb() { return (ld)M * hi + lo; }
};
u128 operator+(const u128 &a, const u128 &b) {
  return u128{(a.lo + b.lo) & (M - 1), a.hi + b.hi + ((a.lo + b.lo) >> 50)};
}
u128 operator-(const u128 &a, const u128 &b) {
  if (a.lo >= b.lo)
    return u128{a.lo - b.lo, a.hi - b.hi};
  else
    return u128{a.lo - b.lo + M, a.hi - b.hi - 1};
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  int n, x;
  cin >> n >> x;
  vector<int> a(n);
  int s = 0;
  for (int i = 0; i < n; ++i) {
    cin >> a[i];
    s += a[i];
  }
  if (*max_element(a.begin(), a.end()) == x) {
    cout << x * n << "\n";
    return 0;
  }
  vector<vector<u128>> c(n + 1, vector<u128>(n + 1));
  for (int i = 0; i <= n; ++i) {
    c[i][0] = u128{1, 0};
    for (int j = 1; j <= i; ++j) {
      c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
    }
  }
  vector<ld> sum(n + 1);
  for (int i = 0; i < n; ++i) {
    sum[i + 1] = sum[i] + ((ld)n / (n - i) + 1) * x / 2;
  }
  vector<vector<u128>> dp(n + 1, vector<u128>(s + 1));
  dp[0][0] = u128{1, 0};
  for (int w : a) {
    for (int i = n; i; --i) {
      for (int j = s; j >= w; --j) {
        dp[i][j] = dp[i][j] + dp[i - 1][j - w];
      }
    }
  }
  ld ans = 0;
  for (int w : a) {
    vector<vector<u128>> new_dp = dp;
    for (int i = 1; i <= n; ++i) {
      for (int j = w; j <= s; ++j) {
        new_dp[i][j] = new_dp[i][j] - new_dp[i - 1][j - w];
      }
    }
    for (int i = 0; i < n; ++i) {
      for (int j = 0; j <= s - w; ++j) {
        ld cost = ((ld)n / (i + 1) + 1) * x / 2;
        ld ave = (ld)(j + w) / (i + 1);
        if (ave > cost) {
          ld cost2 = !i ? 0 : ((ld)n / i + 1) * x / 2;
          ld ave2 = !i ? 0 : (ld)j / i;
          if (ave2 <= cost2) {
            ans += new_dp[i][j].todb() / c[n][i + 1].todb() / (i + 1) *
                   (sum[n - i] + j);
          }
        }
      }
    }
  }
  cout << fixed << setprecision(20) << ans << "\n";
  return 0;
}