#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#include <random>
#include <unordered_map>
#include <unordered_set>
#include <assert.h>
#include <climits>
#include <iomanip>
using namespace std;

using ll = long double;
struct Line
{ // tested with $N,Q\leq 2\cdot 10^5$ (296 ms)
  mutable ll k, m, p;
  int id;
  bool operator<(const Line &o) const { return k < o.k; }
  bool operator<(ll x) const { return p < x; }
};
struct LineContainer : multiset<Line, less<>>
{
  // (for doubles, use inf = 1/.0, div(a,b) = a/b)
  ll inf = 1 / .0;
  ll div(ll a, ll b)
  { // floored division
    return a / b;
  }
  bool isect(iterator x, iterator y)
  {
    if (y == end())
      return x->p = inf, 0;
    if (x->k == y->k)
      x->p = x->m > y->m ? inf : -inf;
    else
      x->p = div(y->m - x->m, x->k - y->k);
    return x->p >= y->p;
  }
  void add(ll k, ll m, int id)
  {
    auto z = insert({k, m, 0, id}), y = z++, x = y;
    while (isect(y, z))
      z = erase(z);
    if (x != begin() && isect(--x, y))
      isect(x, y = erase(y));
    while ((y = x) != begin() && (--x)->p >= y->p)
      isect(x, erase(y));
  }
  pair<ll, int> query(ll x)
  {
    assert(!empty());
    auto l = *lower_bound(x);
    return {l.k * x + l.m, l.id};
  }
};

void solve([[maybe_unused]] int t)
{
  int n;
  cin >> n;
  LineContainer ds;

  int last = 0;
  vector<int> sol;
  vector<long double> p(n + 1);

  for (int i = 1; i <= n; i++)
  {
    cin >> p[i];

    if (p[i] == 1)
    {
      last = i;
      sol.push_back(i);
      continue;
    }

    long double coeff = p[i] / (1 - p[i]);
    ds.add(-coeff, i * coeff, i);

    // cout << i * coeff << " val\n";
  }

  long double ans = 0;
  while (ds.size() > 0 && ds.query(last).first > 0)
  {
    sol.push_back(ds.query(last).second);
    last = sol.back();
  }

  long double prob = 1.0;
  last = 0;
  for (auto i : sol)
  {
    assert(i > last);
    ans += last * prob * (1 - p[i]);
    last = i;
    prob *= p[i];
  }
  ans += last * prob;

  // for (auto i : sol)
  //   cout << i << " ecco\n";

  cout << fixed << setprecision(18) << ans << "\n";
}

int main()
{
  ios::sync_with_stdio(false);
  cin.tie(0);

  int n = 1;
  // cin >> n;
  for (int i = 1; i <= n; i++)
    solve(i);
}