Problem: You have a circle of length C, and you are placing N arcs on it. Arc i has length L_i.

Every arc i is placed on the circle uniformly at random: a random real point on the circle is chosen, then an arc of length L_i centered at this point appears.

Note that the arcs are placed independently. For example, they may intersect or contain each other.

What is the probability that every real point of the circle will be covered by at least one arc? Assume that an arc covers its ends.

Constraints

* 2 \leq N \leq 6
* 2 \leq C \leq 50
* 1 \leq L_i < C
* All input values are integers.

Input

Input is given from Standard Input in the following format:


N C
L_1 L_2 ... L_N


Output

Print the probability that every real point of the circle will be covered by at least one arc. Your answer will be considered correct if its absolute error doesn't exceed 10^{-11}.

Examples

Input

2 3
2 2


Output

0.3333333333333333


Input

4 10
1 2 3 4


Output

0.0000000000000000


Input

4 2
1 1 1 1


Output

0.5000000000000000


Input

3 5
2 2 4


Output

0.4000000000000000


Input

4 6
4 1 3 2


Output

0.3148148148148148


Input

6 49
22 13 27 8 2 19


Output

0.2832340720702695

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;

using ll=int64_t;
#define int ll

#define FOR(i,a,b) for(int i=int(a);i<int(b);i++)
#define REP(i,b) FOR(i,0,b)
#define MP make_pair
#define PB push_back
#define ALL(x) x.begin(),x.end()
#define REACH cerr<<"reached line "<<__LINE__<<endl
#define DMP(x) cerr<<"line "<<__LINE__<<" "<<#x<<":"<<x<<endl
#define ZERO(x) memset(x,0,sizeof(x))

using pi=pair<int,int>;
using vi=vector<int>;
using ld=long double;

template<class T,class U>
ostream& operator<<(ostream& os,const pair<T,U>& p){
	os<<"("<<p.first<<","<<p.second<<")";
	return os;
}

template<class T>
ostream& operator <<(ostream& os,const vector<T>& v){
	os<<"[";
	REP(i,(int)v.size()){
		if(i)os<<",";
		os<<v[i];
	}
	os<<"]";
	return os;
}

int read(){
	int i;
	scanf("%" SCNd64,&i);
	return i;
}

void printSpace(){
	printf(" ");
}

void printEoln(){
	printf("\n");
}

void print(int x,int suc=1){
	printf("%" PRId64,x);
	if(suc==1)
		printEoln();
	if(suc==2)
		printSpace();
}

string readString(){
	static char buf[3341000];
	scanf("%s",buf);
	return string(buf);
}

char* readCharArray(){
	static char buf[3341000];
	static int bufUsed=0;
	char* ret=buf+bufUsed;
	scanf("%s",ret);
	bufUsed+=strlen(ret)+1;
	return ret;
}

template<class T,class U>
void chmax(T& a,U b){
	if(a<b)
		a=b;
}

template<class T,class U>
void chmin(T& a,U b){
	if(a>b)
		a=b;
}

template<class T>
T Sq(const T& t){
	return t*t;
}

const int inf=LLONG_MAX/3;

ld pou(ld x,int a){
	ld res=1;
	REP(i,a)res*=x;
	return res;
}

const int Nmax=20;
int binom[Nmax][Nmax];
void Init(){
	binom[0][0]=1;
	REP(i,Nmax)REP(j,Nmax){
		if(i-1>=0)binom[i][j]+=binom[i-1][j];
		if(j-1>=0)binom[i][j]+=binom[i][j-1];
	}
}
int Choose(int a,int b){
	return binom[a-b][b];
}

map<pi,ld> mult(map<pi,ld>a,map<pi,ld>b){
	map<pi,ld> res;
	for(auto kv1:a)for(auto kv2:b){
		int t=kv1.first.first+kv2.first.first;
		int x=kv1.first.second+kv2.first.second;
		res[pi(t,x)]+=kv1.second*kv2.second;
	}
	return res;
}

map<pi,ld> rev(map<pi,ld>a){
	map<pi,ld>res;
	for(auto kv:a)
		res[pi(kv.first.second,kv.first.first)]=kv.second;
	return res;
}

map<pi,ld> integrate(map<pi,ld>a,ld b,ld c){
	map<pi,ld>res;
	for(auto kv:a){
		int t=kv.first.first,x=kv.first.second;
		REP(i,t+2){
			if(i%2==0){
				res[pi(0,t+1-i+x)]+=kv.second/(t+1)*pou(c,i)*Choose(t+1,i);
			}else{
				res[pi(0,t+1-i+x)]-=kv.second/(t+1)*pou(c,i)*Choose(t+1,i);
			}
		}
		res[pi(0,x)]-=kv.second/(t+1)*pou(b,t+1);
	}
	return res;
}

ld solve(const vector<ld>&use,const vector<ld>&rem,const vi&idx){
	//cerr<<use<<" "<<rem<<" "<<idx<<endl;
	map<pi,ld> f;
	f[pi(0,0)]=1;
	ld b=use[0];
	int n=use.size(),m=rem.size();
	REP(i,m)if(idx[i]==0){
		map<pi,ld>g;
		g[pi(0,0)]=-rem[i];
		g[pi(0,1)]=1;
		f=mult(f,g);
		chmax(b,rem[i]);
	}
	FOR(i,1,n){
		ld w=use[i];
		f=rev(f);
		REP(j,m)if(idx[j]==i){
			map<pi,ld>g;
			g[pi(0,0)]=-rem[j];
			g[pi(0,1)]=1;
			g[pi(1,0)]=-1;
			f=mult(f,g);
			chmax(w,rem[j]);
		}
		f=integrate(f,b,w);
		b+=w;
	}
	ld ans=0;
	if(b<1)
		for(auto kv:f)
			ans+=kv.second;
	//cerr<<ans<<endl;
	return ans;
}

ld sub(const vector<ld>&use,const vector<ld>&rem,int i,vi&idx){
	if(i==int(rem.size()))
		return solve(use,rem,idx);
	ld ans=0;
	REP(j,use.size()){
		idx[i]=j;
		ans+=sub(use,rem,i+1,idx);
	}
	return ans;
}

ld calc(const vector<ld>&use,const vector<ld>&rem){
	int n=use.size();
	vi perm(n);REP(i,n)perm[i]=i;
	ld res=0;
	do{
		vector<ld> tmp(use.size());
		REP(i,use.size())tmp[i]=use[perm[i]];
		vi idx(rem.size());
		res+=sub(tmp,rem,0,idx);
	}while(next_permutation(perm.begin()+1,perm.end()));
	return res;
}

signed main(){
	Init();
	int n=read(),c=read();
	vector<ld> l(n);
	REP(i,n){
		l[i]=read();
		l[i]/=c;
	}
	ld ans=0;
	FOR(bit,1,1<<n){
		vector<ld> use,rem;
		REP(i,n)
			if((bit>>i)&1)
				use.PB(l[i]);
			else
				rem.PB(l[i]);
		ld w=calc(use,rem);
		if(int(use.size())%2==1)
			ans+=w;
		else
			ans-=w;
	}
	cout<<fixed<<setprecision(20)<<1.0-ans<<endl;
}