#include <iostream>
#include <vector>
#include <array>
#include <string>
#include <algorithm>
#include <iomanip>
#include <map>
#include <deque>

using namespace std;
#define ld long double
const ld INF = 1e18;

struct line {
    ld k, b;
    ld eval(ld x) {
        return k * x + b;
    }
};
struct part {
    line a;
    ld x;
};
ld intersection(line a, line b) {
    return (ld) (a.b - b.b) / (b.k - a.k);
}
struct ConvexHullMin {
    vector <part> st;
    void add(line a) {
        if (!st.empty() && st.back().a.k == a.k) {
            if (st.back().a.b > a.b) st.pop_back();
            else return;
        }
        while (st.size() > 1 && intersection(st[st.size() - 2].a, a) <= st[st.size() - 2].x) st.pop_back();
        if (!st.empty()) st.back().x = intersection(st.back().a, a);
        st.push_back({a, INF});
    }
    ld get_val(ld x) {
        int l = -1, r = (int)st.size() - 1;
        while (r - l > 1) {
            int m = (l + r) / 2;
            if (st[m].x < x) l = m;
            else r = m;
        }
        return st[r].a.eval(x);
    }
};

void solve() {
    int n;
    cin >> n;
    vector <ld> p(n + 1);
    p[0] = 1;
    for (int i = 1; i <= n; ++i) cin >> p[i];
//
//    vector <ld> dp1(n + 1);
//
//    dp1[n] = n;
//
//    for (int i = n - 1; i >= 0; --i) {
//        dp1[i] = i;
//        for (int j = i + 1; j <= n; ++j) {
//            dp1[i] = max(dp1[i], i + (-i) * p[j] + p[j] * dp1[j]);
//        }
//    }
//
//    cout << dp1[0] << "\n";
    vector <ld> dp(n + 1);
    dp[n] = n;
    ConvexHullMin now;

    now.add({-p[n], -p[n] * dp[n]});

    for (int i = n - 1; i >= 0; --i) {
        dp[i] = max(-now.get_val(-i), (ld)0) + i;
        now.add({-p[i], -p[i] * dp[i]});
    }

    cout << fixed << setprecision(10) << dp[0];
}

signed main() {
    if (1) {
        ios_base::sync_with_stdio(false);
        cin.tie(nullptr);
    }
    int t = 1;
//    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}

/*
5
0.9 0.85 0.6 0.456000 0.000000017
 */