//%^~
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
// #include <bits/stdc++.h>
#include <cstdio>
#include <cstring>
#include <string>
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <functional>
#include <limits>
#include <unordered_set>
#include <unordered_map>
#include <cmath>
// #include "ext/pb_ds/assoc_container.hpp"
// #include "ext/pb_ds/tree_policy.hpp"
// #include "ext/pb_ds/priority_queue.hpp"
// #include <ext/rope>
// #define PBDS __gnu_pbds
// #include <bits/extc++.h>
#define MAXN 200005
#define eps 1e-10
#define foru(a, b, c) for (int a = (b); (a) <= (c); (a)++)
#define ford(a, b, c) for (int a = (b); (a) >= (c); (a)++)
#define uLL unsigned long long
#define LL long long
#define LXF int
#define RIN Cap1taLDebug::read()
#define RSIN Cap1taLDebug::rdstr()
#define RCIN Cap1taLDebug::rdchar()
#define HH printf("\n")
// #define double long double
#define All(x) (x).begin(), (x).end()
#define fi first
#define se second
#define CA const auto&
using namespace std;
// const int RANDOM = time(0);
// template<class T1,class T2>
// class tr1::hash<pair<T1,T2>>{
// public:
	// size_t operator () (pair<T1,T2> x)const{
		// tr1::hash<T1> H1;
		// tr1::hash<T2> H2;
		// return H1(x.fi)^H2(x.se)^RANDOM;
	// }
// };
int ID;
class Cap1taLDebug{
	#ifdef LXF
	#define READTYPE LXF
	#else
	#define READTYPE int
	#endif
	#define DEBUGING
private:
	ostream& buf;
	#ifndef DEBUGING
	static char fbuf[1<<21],*p1,*p2;
	#define getchar() (Cap1taLDebug::p1==p2&&(p1=(p2=fbuf)+fread(fbuf,1,1<<21,stdin),p1==p2)?EOF:*p2++)
	#endif
public:
	Cap1taLDebug(ostream& out=cout):buf(out){}
	~Cap1taLDebug(){
		#ifdef DEBUGING
		buf.flush();
		#endif
	}
	static READTYPE read(){
		READTYPE x=0,w=1;char ch=0;
		while(!isdigit(ch)){
		if(ch=='-')	w=-1;
		ch=getchar();
		}
		while(isdigit(ch))	x=x*10+(ch^48),ch=getchar();
		return x*w;
	}
	static string rdstr(){
		string s;char c=getchar();
		while(c==' ' || c=='\r' || c=='\n')	c=getchar();	
		while(c!=' ' && c!='\r' && c!='\n' && c!=EOF)	s+=c,c=getchar();
		return s;
	}
	static char rdchar(){
		char c=getchar();
		while(c==' ' || c=='\r' || c=='\n')	c=getchar();
		return c;
	}
	static string int128ToString(__int128 x){
		if(x==0)	return "0";
		string s="",w="";
		if(x<0)	w="-",x*=-1;
		while(x) s+=(char)('0'+(int)(x%10)),x/=10;
		reverse(All(s));
		return w+s;
	}
	Cap1taLDebug& operator<<(const string val){
		#ifdef DEBUGING
		buf<<val;
		#endif
		return *this;
	}
	template<typename T1,typename T2>
	Cap1taLDebug& operator<<(const pair<T1,T2>& val){
		#ifdef DEBUGING
		(*this)<<"("<<val.first<<","<<val.second<<")";
		#endif
		return *this;
	}
	template<typename T,template<typename,typename...>class Container,typename...Args>
	Cap1taLDebug& operator<<(const Container<T, Args...>& container){
		#ifdef DEBUGING
		buf<<"{";
		bool fst=0;
		for(const auto& val:container){
			if(!fst)	fst=true;
			else	buf<<",";
			(*this)<<val;	
		}
		buf<<"}";
		#endif
		return *this;
	}
	Cap1taLDebug& operator<<(const __int128& val){
		#ifdef DEBUGING
		buf<<int128ToString(val);
		#endif
		return *this;
	}
	template<typename T>
	Cap1taLDebug& operator<<(const T& val){
		#ifdef DEBUGING
		buf<<val;
		#endif
		return *this;
	}
	Cap1taLDebug& operator<<(ostream& (*manip)(ostream&)){
		#ifdef DEBUGING
		buf<<manip;
		#endif
		return *this;
	}
};
#ifndef DEBUGING
char Cap1taLDebug::fbuf[1<<21],*Cap1taLDebug::p1=nullptr,*Cap1taLDebug::p2=nullptr;
#endif
Cap1taLDebug cein(cout);
// Cap1taLDebug cein(cerr);
ostream& operator<<(ostream& os,__int128 val){
	os<<Cap1taLDebug::int128ToString(val);
	return os;
}
template<typename T>
class Stack : public stack<T>{
public:
	void clear(){
		while(!this->empty())	this->pop();
	}
	void popuntil(const function<bool(T)>& func){
		while(!this->empty() && !func(this->top()))	this->pop();
	}
};
/*

*/
constexpr double E=exp(1);
constexpr double loge=log(E);
constexpr double ln(double x){
	return log(x)/loge;
}
constexpr double y=ln(0.9);

constexpr double K=(0.0-y)/(1.0-0.9);
constexpr double B=-K;
auto f=[](double x){
	return K*x+B;
};
auto g=[](double x){
	return x/K-B/K;
};
int n,m;
double a[MAXN];
class SegTree{
public:
	int l,r;
	double sum;
	double mul;
	double add;
}tr[MAXN<<2];
inline int lc(int x){return x<<1;}
inline int rc(int x){return x<<1|1;}
void push_up(int p){
	tr[p].sum=tr[lc(p)].sum+tr[rc(p)].sum;
}
void updateadd(int p,double k){
	tr[p].sum+=k*(double)(tr[p].r-tr[p].l+1);
	tr[p].add+=k;
}
void updatemul(int p,double k){
	tr[p].sum*=k;
	tr[p].mul*=k;
	tr[p].add*=k;
}
void push_down(int p){
	if(tr[p].mul!=1){
		updatemul(lc(p),tr[p].mul);
		updatemul(rc(p),tr[p].mul);
		tr[p].mul=1;
	}
	if(tr[p].add!=0){
		updateadd(lc(p),tr[p].add);
		updateadd(rc(p),tr[p].add);
		tr[p].add=0;
	}
}
void Build(int p,int l,int r){
	tr[p].l=l,tr[p].r=r;
	tr[p].sum=0;
	tr[p].mul=1;
	tr[p].add=0;
	if(l==r){
		tr[p].sum=ln(1.0-a[l]);
		return ;
	}
	int mid=(tr[p].l+tr[p].r)>>1;
	Build(lc(p),l,mid);
	Build(rc(p),mid+1,r);
	push_up(p);
}
void Modifymul(int p,int l,int r,double k){
	if(l<=tr[p].l && tr[p].r<=r){
		updatemul(p,k);
		return ;
	}
	push_down(p);
	int mid=(tr[p].l+tr[p].r)>>1;
	if(l<=mid)	Modifymul(lc(p),l,r,k);
	if(r>mid)	Modifymul(rc(p),l,r,k);
	push_up(p);
}
void Modifyadd(int p,int l,int r,double k){
	if(l<=tr[p].l && tr[p].r<=r){
		updateadd(p,k);
		return ;
	}
	push_down(p);
	int mid=(tr[p].l+tr[p].r)>>1;
	if(l<=mid)	Modifyadd(lc(p),l,r,k);
	if(r>mid)	Modifyadd(rc(p),l,r,k);
	push_up(p);
}
double Query(int p,int l,int r){
	if(l<=tr[p].l && tr[p].r<=r)	return tr[p].sum;
	int mid=(tr[p].l+tr[p].r)>>1;
	double ret=0;
	push_down(p);
	if(l<=mid)	ret+=Query(lc(p),l,r);
	if(r>mid)	ret+=Query(rc(p),l,r);
	return ret;
}
const int L=1000;
void solve(bool SPE){ 
	
	// for(double i=0.9;i<=1;i+=0.005){
		// double x=ln(i);
		// double y=f(i);
		// cout<<x<<' '<<y<<endl;
		// cout<<exp(x)<<' '<<g(y)<<endl;
	// }
	// cout<<ln(-8);
	while(cin>>n){
		cin>>m;
		foru(i,1,n){
			cin>>a[i];
		}
		Build(1,1,n);
		while(m--){
			int opt;
			cin>>opt;
			if(opt==1){
				int l,r;
				double k;
				cin>>l>>r>>k;
				
				//(1-p)*k+1-k
				
				if(r-l+1<=L){
					foru(i,l,r){
						double x=Query(1,i,i);
						x=ln(exp(x)*k+1-k)-x;
						Modifyadd(1,i,i,x);
					}
				}else{
					Modifymul(1,l,r,k);
					Modifyadd(1,l,r,(B+K)*(1.0-k));
				}
				
				//ln(xc)=ln(x)+ln(c)
				
				// double c=1-k;
				// //f(x+c)=K(x+c)+b=Kx+b+Kc
				// // Modifyadd(1,l,r,K*c);
// 				
				
				
			}else{
				int l,r;
				cin>>l>>r;
				double ans=0;
				
				ans=Query(1,l,r);
				// #undef double
				printf("%.14lf\n",ans);
			}
		}
		
	}
	
	#ifdef DEBUGING
	if(SPE){
		
	}
	#endif
	return ;
}
/*
检查文件读写
检查多测清空
检查数组大小
*/
signed main()
{
	// #define RFILE
	// #define MULTITEST
	// #define TESTCASEID
	
	ios::sync_with_stdio(0);
	cin.tie(0),cout.tie(0);
	
	#ifdef RFILE
	freopen(".in","r",stdin);
	freopen(".out","w",stdout);
	#endif
	
	#ifdef MULTITEST
	int T=RIN;
	#else
	int T=1;
	#endif
	
	#ifdef TESTCASEID
	ID=RIN;
	#endif
	
	for(int i=1;i<=T;i++) solve(i==0);
	return 0;
}