#include <cstdio>
#include <bits/stdc++.h>
#include <algorithm>
#include <iostream>
#include <string>
#include <cmath>
#include <functional>
#include <vector>
#include <stack>
#include <queue>
#include <map>
#define rep(i,n) for (int i=0;i<n;i++)
using ll = long long;
using ull = unsigned ll;
using namespace std;

// const ll inf  = 1e9+5;

// int main (){
// 	int n,k;
// 	vector<ll> dp(n,inf);
// 	cin >> n >> k;
// 	vector<ll> h(n);
// 	for (ll& x :h){
// 		std::cin >> x;
// 	}
// 	dp[0]=0;
// 	for (ll i=0;i<n;i++){
// 		for (ll j=1;j<k+1;j++){
// 			if (0<i+j&&j+i<n){
// 				dp[j+i]=min(dp[j+i],dp[i]+abs(h[j+i]-h[i]));
// 			}
// 		}
// 	}
// 	std::cout << dp[n-1];
// 	return 0;

// }

// int main(void){
// 	ll n;
// 	vector<ll> a(n);
// 	vector<ll> b(n);
//  	vector<ll> c(n);
// 	cin >> n;
// 	for (int i=0;i<n;i++){
// 		int q,w,e;
// 		cin >> q >> w >> e;
// 		a.push_back(q);
// 		b.push_back(w);
// 		c.push_back(e);
// 	}
// 	vector<vector<ll>> dp(n+1,vector<ll>(3));
// 	dp[0][0]=0;
// 	dp[0][1]=0;
// 	dp[0][2]=0;
// 	for (int i=0;i<n;++i){
// 		dp[i+1].push_back(max(dp[i][1]+a[i],dp[i][2]+a[i]));
// 		dp[i+1].push_back(max(dp[i][0]+b[i],dp[i][2]+b[i]));
// 		dp[i+1].push_back(max(dp[i][0]+c[i],dp[i][1]+c[i]));
// 		cout << dp[i+1][0]<< " " << dp[i+1][1] << " " << dp[i+1][2] << endl;
// 	}
// 	cout << max({dp[n][0],dp[n][1],dp[n][2]});
// 	return 0;



// }
// #include "bits/stdc++.h"
// #define ALL(x) x.begin(),x.end()
// #define rep(i,n) for(int i=0;i<n;++i)
 
// using namespace std;
// typedef long long ll;
 

 

 
 
// int main(void){
//     vector<vector<ll>>dp(1e5+10);
//     ll n,a,b,c;
//     cin>>n;
//     vector<vector<ll>>h(n); //happy
//     rep(i,n){
//         cin>>a>>b>>c;
//         h[i].push_back(a);
//         h[i].push_back(b);
//         h[i].push_back(c);
//     }
//     dp[0].push_back(h[0][0]);
//     dp[0].push_back(h[0][1]);
//     dp[0].push_back(h[0][2]);
//     for(int i=1;i<n;++i){
//         dp[i].push_back(max(dp[i-1][1],dp[i-1][2])+h[i][0]);
//         dp[i].push_back(max(dp[i-1][0],dp[i-1][2])+h[i][1]);
//         dp[i].push_back(max(dp[i-1][1],dp[i-1][0])+h[i][2]);
//     }
 
//     cout<<*(max_element(ALL(dp[n-1])));
// }

// int dfs(vector<vector<int>> a,int v,int cnt){
// 	if (a[v].empty()){
// 		int ans=0;
// 		ans=max(ans,cnt);
// 		cout << ans;
// 	}	
// 	for (int next_v:a[v]){
// 		cnt+=1;
// 		dfs(a,next_v,cnt);
// 	}
// 	return 0;

	
// }


// int n,m;
// vector<vector<int>> g;
// int dp[100100];

// int dfs(int v){
// 	if (dp[v]!=-1){
// 		return dp[v];
// 	}

// 	int ans=0;
// 	for (auto nv:g[v]){
// 		ans = max(ans,dfs(nv)+1);

// 	}
// 	return dp[v]=ans;

// }

// int main (){
// 	cin >> n >> m;
// 	g.assign(n,vector<int>());

// 	for (int i=0;i<m;i++){
// 		int a,b;
// 		cin >> a >> b;
// 		--a;
// 		--b;

// 		g[a].push_back(b);
// 	}

// 	for (int i=0;i<n;i++){
// 		dp[i]=-1;
// 	}

// 	int ans=0;
// 	for (int i=0;i<n;i++){
// 		ans=max(ans,dfs(i));
// 	}
// 	cout << ans << endl;
// 	return 0;
// }

// int h,w,cnt=0,ans=0;
// ll mod=1000000007;
// vector<vector<string>> m;

// void dfs(int x,int y,vector<vector<string>> m){
// 	if (x+1<w && m[y][x+1]=="."){
// 		dfs(x+1,y,m);
// 	}
// 	if (y+1<h && m[y+1][x]=="."){
// 		dfs(x,y+1,m);
// 	}
// 	if (x==w-1 && y==h-1){
// 		cnt+=1;
// 	}
// }

// int main() {
// 	cin >> h >>w;
// 	m.assign(h,vector<string>(w));
// 	for (int i=0;i<h;i++){
// 		for (int j=0;j<w;j++){
// 			cin >> m[i][j];
// 		}
// 	}
// 	dfs(0,0,m);
// 	cout << cnt%mod;
// 	return 0;

// }

// int const mod=1e9+7;
// int const hmax=1000;
// int const wmax=1000;
// int h,w;
// char grid[1+hmax][1+wmax];
// int dp[1+hmax][1+wmax];


// int main() {
// 	cin >> h >> w;
// 	for (int i=1;i<=h;i++){
// 		for (int j=1;j<=w;j++){
// 			cin >> grid[i][j];
// 		}
// 	}

// 	dp[1][1]=1;
// 	for (int i=1;i<=h;i++){
// 		for (int j=1;j<=w;j++){
// 			if (grid[i][j]=='.'){
// 				if (i-1>0&&grid[i-1][j]=='.'){
// 					dp[i][j]+=dp[i-1][j];
// 				}
// 				if (j-1>0&&grid[i][j-1]=='.'){
// 					dp[i][j]+=dp[i][j-1];

// 				}
// 			}
// 			dp[i][j]%=mod;

// 		}
// 	}
// 	cout << dp[h][w];
// }

int const nmax=3000;

int main (){
    int n,m;
    cin >> n;
    m = n/2 +1;
    double dp[n+1][n+1];
    double p[n+1];
    for (int i=1;i<n+1;i++){
        cin >> p[i];
    }

    memset(dp,0.0,sizeof(dp));

    dp[0][0]=1.0;
    
    for (int i=1;i<n+1;i++){
        for (int j=0;j<n+1;j++){
            if (j==0){
                dp[i][j]=dp[i-1][j]*(1.0-p[i]);
            }
            else{
                dp[i][j]=dp[i-1][j]*(1.0-p[i])+dp[i-1][j-1]*p[i];
            }
        }
    }
    double ans=0.0;
    for (int i=m;i<n+1;i++){
        ans+=dp[n][i];
    }
    cout << setprecision(10) << ans << endl;

}










Measured memory_bytes: 70528