#include <bits/stdc++.h>
#ifndef ONLINE_JUDGE
#ifdef CPH
#include "/home/floze3/OI/debug.cpp"
#else 
#include "/home/floze3/OI/debug_colored.cpp"
#endif
#else
#define debug(...) 42
#define debugArr(...) 42
#define look_time 42
#define look_memory 42
#endif
#define mp(x, y) std::make_pair(x, y)
#define mt std::make_tuple
#define eb emplace_back
#define fi first
#define se second
#define all(s) s.begin(), s.end()
#define rall(s) s.rbegin(), s.rend()
#define file(name)                 \
  freopen(name ".in", "r", stdin); \
  freopen(name ".out", "w", stdout);
#define fs(x) std::fixed << std::setprecision(x)
#define lowbit(x) (x & -x)
#define il inline
#define Avada_Kedavra return 0
#define _IOS                        \
  std::ios::sync_with_stdio(false); \
  std::cin.tie(nullptr), std::cout.tie(nullptr)
#define RANDOM_SEED std::chrono::steady_clock::now().time_since_epoch().count()
#define popcount __builtin_popcount
#define popcountll __builtin_popcountll
#define multitask    \
  int _; rd >> _; \
  while (_--)
using std::cerr;

namespace TYPEDEF {

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned int;
using i128 = __int128;
using pii = std::pair<int, int>;
using pi64 = std::pair<i64, i64>;
using vi = std::vector<int>;
using vi64 = std::vector<i64>;
using vu64 = std::vector<u64>;
using vpii = std::vector<pii>;
using vpi64 = std::vector<pi64>;
using si = std::stack<int>;
using si64 = std::stack<i64>;
using su64 = std::stack<u64>;
using spii = std::stack<pii>;
using spi64 = std::stack<pi64>;
using qi = std::queue<int>;
using qi64 = std::queue<i64>;
using qu64 = std::queue<u64>;
using qpii = std::queue<pii>;
using qpi64 = std::queue<pi64>;
using siset = std::set<int>;
using si64set = std::set<i64>;
using su64set = std::set<u64>;
using spiiset = std::set<pii>;
using spi64set = std::set<pi64>;
using str = std::string;
using vstr = std::vector<str>;
using f64 = long double;

} // namespaec TYPEDEF

using namespace TYPEDEF;

struct Scanner {
  FILE* stream;
  Scanner(FILE* s): stream(s) {}
  char buf[1 << 20], *l = buf, *r = buf;
  bool flush() { l = buf; r = l + fread(buf, 1, 1 << 20, stream); return l == r; }
  void get(char& c) {
#ifndef ONLINE_JUDGE
    c = getchar();
#else
    c = l == r && flush() ? ' ' : *l++;
#endif
  }

  friend Scanner &operator>>(Scanner &in, char& c) { return in.get(c), in; }

  friend Scanner &operator>>(Scanner &in, char* s) {
    for (in.get(s[0]); isspace(s[0]); in.get(s[0]));
    for (int i = 0; !isspace(s[i]) || (s[i] = '\0'); i++) in.get(s[i + 1]);
    return in;
  }

  friend Scanner &operator>>(Scanner &in, std::string &s) {
    char c;
    for (in.get(c); isspace(c); in.get(c));
    for (s = ""; !isspace(c); in.get(c)) s += c;
    return in;
  }

  friend Scanner &operator>>(Scanner &in, i128 &x) {
    char c, f = '+';
    for (in.get(c); !isdigit(c); in.get(c))
      if (c == '-') f = c;
    for (x = 0; isdigit(c); in.get(c)) x = (x << 1) + (x << 3) + c - '0';
    if (f == '-') x = -x;
    return in;
  }

  template<class T> friend Scanner &operator>>(Scanner &in, T &x) {
    if (std::is_integral<T>()) {
      char c, f = '+';
      for (in.get(c); !isdigit(c); in.get(c))
        if (c == '-') f = c;
      for (x = 0; isdigit(c); in.get(c)) x = x * 10 + c - '0';
      if (f == '-') x = -x;
      return in;
    }
    else {
      std::string s;
      in >> s;
      x = std::stod(s);
      return in;
    }
  }
};

struct Printer {
  FILE* stream;
  Printer(FILE* s): stream(s) {}
  char buf[1 << 20], *l = buf, *r = buf + (1 << 20) - 1;
  int format = 0, precision = 15;
  ~Printer() { flush(); }

  void flush() { fwrite(buf, 1, l - buf, stream); l = buf; }
  void put(const char& c) {
#ifndef ONLINE_JUDGE
    putchar(c);
#else
    *l++ = c;
    if (l == r) flush();
#endif
  }

  friend Printer &operator<<(Printer &out, const char &c) {
    return out.put(c), out;
  }

  friend Printer &operator<<(Printer &out, const char* s) {
    for (int i = 0; s[i] != '\0'; i++) out.put(s[i]);
    return out;
  }

  friend Printer &operator<<(Printer &out, char* s) {
    for (int i = 0; s[i] != '\0'; i++) out.put(s[i]);
    return out;
  }

  friend Printer &operator<<(Printer &out, const std::string &s) {
    for (int i = 0, n = s.size(); i < n; i++) out.put(s[i]);
    return out;
  }

  friend Printer &operator<<(Printer &out, i128 x) {
    static int s[40], top = 0;
    if (x < 0) out.put('-'), x = -x;
    do s[++top] = x % 10, x /= 10; while (x);
    while (top) out.put(s[top--] + '0');
    return out;
  }

  template<class T> friend Printer &operator<<(Printer &out, T x) {
    if (std::is_integral<T>()) {
      static int s[40], top = 0;
      i64 nx = x;
      if (nx < 0) out.put('-'), nx = -nx;
      do s[++top] = nx % 10, nx /= 10; while (nx);
      while (top) out.put(s[top--] + '0');
      return out;
    }
    else {
      std::ostringstream oss;
      oss << std::fixed << std::setprecision(out.precision) << x;
      return out << oss.str();
    }
    return out;
  }
};

Scanner rd(stdin);
Printer wt(stdout);

/*===============================ALGOS===============================*/

namespace basic_algorithm {
template <typename T> il T abs(T a) { return a >= 0 ? a : -a; }
template <typename T> il void chmin(T &a, T b) { if (a > b) a = b; }
template <typename T> il void chmax(T &a, T b) { if (a < b) a = b; }
}  // namespace basic_algorithm

using namespace basic_algorithm;

/*================================END================================*/

constexpr int N = 4100;
constexpr int mod = 1e9 + 7;
constexpr int inf = 0x3f3f3f3f;
constexpr i64 inf64 = 0x3f3f3f3f3f3f3f3fll;

std::mt19937 rng(RANDOM_SEED);

bool mst;

int n, x, a[N], pos[N];
bool med;

struct node {
  int l, r;
  std::vector<f64> f;

  #define ls (p << 1)
  #define rs (ls | 1)
  #define mid ((t[p].l + t[p].r) >> 1)
} t[N << 2];

void pushup(int p, int l, int r) {
  std::fill(all(t[p].f), 0);
  // for (int i = 0; i < t[p].f.size(); ++i) t[p].f[i] = 0;
  for (int i = 0; i < t[ls].f.size(); ++i) {
    for (int j = 0; j < t[rs].f.size(); ++j) {
      int id1 = l + i, id2 = l + t[ls].f.size() + j;
      t[p].f[i] += t[ls].f[i] * t[rs].f[j] * (1.0 * a[id1] / (a[id1] + a[id2]));
      t[p].f[j + t[ls].f.size()] += t[ls].f[i] * t[rs].f[j] * (1.0 * a[id2] / (a[id1] + a[id2]));
    }
  }
  return ;
}

void build(int p, int l, int r) {
  t[p].l = l, t[p].r = r, t[p].f.resize(r - l + 1);
  if (l == r) return t[p].f[0] = 1.0, pos[l] = p, void();
  build(ls, l, mid), build(rs, mid + 1, r);
  return pushup(p, l, r);
}

void rebuild(int p) {
  if (t[p].l == t[p].r) return ;
  rebuild(ls), rebuild(rs);
  pushup(p, t[p].l, t[p].r);
}

signed main() {
  rd >> n >> x;
  for (int i = 1; i < n; ++i) rd >> a[i];
  a[0] = x;
  build(1, 0, n - 1);
  wt << t[1].f[0] << '\n';
  for (int i = 1; i < n; ++i) {
    int lp = pos[i - 1], rp = pos[i];
    std::swap(a[i - 1], a[i]);
    while (lp != rp) lp >>= 1, rp >>= 1;
    rebuild(lp);
    f64 res = t[lp].f[i - t[lp].l];
    while (lp != 1) {
      rp = lp ^ 1;
      f64 nres = 0;
      for (int j = 0; j < t[rp].f.size(); ++j) {
        nres += res * t[rp].f[j] * 1.0 * x / (x + a[t[rp].l + j]);
      }
      res = nres;
      lp >>= 1;
    }
    wt << res << '\n';
  }
  Avada_Kedavra;
}

/*
all the things you do
the words you say
it all comes back to you
*/