#include <stdio.h>
#include <math.h>
#include <algorithm>
#include <climits>
#include <vector>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <iostream>
#include <string.h>

using namespace std;

const int INF = INT_MAX >> 1;
const int MOD = 1'000'000'000 + 7;
int N;

double dfs(const int ST, vector<double> &expec, vector<double> const &faceUp, vector<double> const &faceDown) {
    if(expec[ST] >= 0) {
        return expec[ST];
    }

    double psum = 0.0;
    double Esum = 0.0;
    for(int i = 0; i < N; ++i) {
        if(ST & (1 << i)) {
            int afterKick = (ST ^ (1 << i));
            double curP = faceUp[1<<i] * faceDown[afterKick] + faceDown[1<<i] * faceUp[afterKick];

            Esum += curP * dfs(afterKick, expec, faceUp, faceDown);
            psum += curP;
        }
    }

    expec[ST] = (1 + Esum) / psum;
    return expec[ST];
}

void solve(int testCase) {
    scanf("%d", &N);
    vector<double> ps(N, 0.0);
    for(int i = 0; i < N; ++i)
        scanf("%lf", &ps[i]);
    
    // if(2 == N) {
        
    //     return;
    // }

    const int MAXSZ = 1 << N;
    vector<double> expec(MAXSZ, -1);
    for(int i = 0; i < N; ++i) {
        for(int j = i + 1; j < N; ++j) {
            expec[(1 << i) | (1 << j) ] = 0;
        }
    }

    vector<double> faceUp(MAXSZ, 1), faceDown(MAXSZ, 1);
    for(int i = 0; i < N; ++i) {
        for(int state = 1; state < MAXSZ; ++state) {
            if(state & (1 << i)) {
                faceUp[state] *= ps[i];
                faceDown[state] *= (1 - ps[i]);
            }
        }
    }

    dfs(MAXSZ - 1, expec, faceUp, faceDown);

    printf("%.7lf\n", expec[MAXSZ-1]);
}  

bool multi = false;

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int t = 1;
    if (multi) {
        cin >> t;
    }
    for (int i = 1; i <= t; ++i) {
        solve(i);
        // cout << "\n";
    }
    return 0;
}