#include <bits/stdc++.h>
using namespace std ;
#define vec point
typedef double db;
const db eps = 1e-6;
const db pi = acos(-1.0);
const db inf = 40000;
int sgn(db x) {
    if (x < -eps)
        return -1;
    else if (x > eps)
        return 1;
    else
        return 0;
}
int cmp(db x, db y) { return sgn(x - y); }
void print(int num, db x) { cout << fixed << setprecision(num) << x << '\n'; }
struct point {
    db x, y;
    point() {}
    point(db x2, db y2) { x = x2, y = y2; }
    void input() {
        int x2, y2;
        cin >> x2 >> y2;
        x = x2;
        y = y2;
    }
    point operator+(const point &s) const { return (point){x + s.x, y + s.y}; }
    point operator-(const point &s) const { return (point){x - s.x, y - s.y}; }
    point operator*(const db &k) const { return (point){x * k, y * k}; }
    point operator/(const db &k) const { return (point){x / k, y / k}; }
    db operator*(const point &a) const { return x * a.x + y * a.y; }
    db operator^(const point &a) const { return x * a.y - y * a.x; }
    bool operator<(point b) const { return sgn(x - b.x) == 0 ? sgn(y - b.y) < 0 : x < b.x; }
    bool equal(point p2) { return cmp(x, p2.x) == 0 && cmp(y, p2.y) == 0; }
    db get_angle() { return atan2(y, x); }
    int getP() const { return sgn(y) == 1 || (sgn(y) == 0 && sgn(x) == -1); }
    db sq(db x) { return x * x; }
    db dis(point p) { return sqrtl(sq(x - p.x) + sq(y - p.y)); }
    db len() { return sqrtl(sq(x) + sq(y)); }
    db len2() { return sq(x) + sq(y); }
    point unit() {
        db w = len();
        return (point){x / w, y / w};
    }
    vec rotate_left() { return vec(-y, x); }
    vec rotate_right() { return vec(y, -x); }
    point move(db r) {
        db l = len();
        if (sgn(l) == 0)
            return *this;
        else
            return point(x * r / l, y * r / l);
    }
    vec rotate(db ang) { return vec({x * cos(ang) - y * sin(ang), y * cos(ang) + x * sin(ang)}); }
};
db cross(vec s, vec t) { return s.x * t.y - s.y * t.x; }
db dot(vec s, vec t) { return s.x * t.x + s.y * t.y; }
void solve()
{
    int n ;
    cin >> n ;
    vector<db> p(n) ;
    for(int i = 0 ; i < n ; i ++)  cin >> p[i] ;
    // dp[i] = \max val[i] * lose[j] + win[i] * dp[j]
    vector<db> dp(n) ;
    dp[n - 1] = p[n - 1] * n ;
    vector<vec> v ;
    auto add = [&](int id)
    {
        db x = 1.0 - p[id] ;
        db y = dp[id] ;
        vec v3 = {x , y} ;
        while(v.size() >= 2)
        {
            vec v2 = v.back() ; v.pop_back() ;
            vec v1 = v.back() ;
            if(sgn(cross(v2 - v1 , v3 - v2)) >= 0)
            {
                v.push_back(v2) ;
                break ;
            }
        }
        v.push_back(v3) ;
    } ;
    add(n - 1) ;
    for(int i = n - 2 ; i >= 0 ; i --)
    {
        vec now = {p[i] * (i + 1) , p[i]} ;
        int l = 0 , r = v.size() - 1 ;
        auto cal = [&](int id)
        {
            return dot(v[id] , now) ;
        } ;
        while(r - l >= 5)
        {
            db lmid = (2 * l + r) / 3 ;
            db rmid = (2 * r + l + 2) / 3 ;
            if(cal(lmid) >= cal(rmid))  r = rmid - 1 ;
            else  l = lmid + 1 ;
        }
        for(int j = l ; j <= r ; j ++)  dp[i] = max(dp[i] , dot(now , v[j])) ;
        add(i) ;
    }
    cout << fixed << setprecision(12) << *max_element(dp.begin() , dp.end()) << '\n' ;
}
int main()
{
    std::ios::sync_with_stdio(false) , cin.tie(0) ;

    int T = 1 ;
    while (T --)  solve() ;

    return 0 ;
}