#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")

#include<bits/stdc++.h>
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define mt make_tuple
#define poly vector<node>
typedef long long ll;
typedef double ld;
using namespace std;
const int N=1000010,INF=0x3f3f3f3f;

const ld eps=1e-9,pi=acos(-1),inf=1e18;

mt19937_64 rnd(chrono::steady_clock::now().time_since_epoch().count());

int dcmp(ld x){return x<-eps?-1:(x>eps?1:0);}

struct node{
	ld x,y;
	node(ld xx=0,ld yy=0){x=xx,y=yy;}
	bool operator <(const node &a)const{return dcmp(x-a.x)?x<a.x:y<a.y;}
	bool operator ==(const node &a)const{return !dcmp(x-a.x)&&!dcmp(y-a.y);}
	node &operator +=(const node &b){x+=b.x,y+=b.y;return *this;}
	node &operator -=(const node &b){x-=b.x,y-=b.y;return *this;}
	node &operator *=(const ld &b){x*=b,y*=b;return *this;}
	node &operator /=(const ld &b){x/=b,y/=b;return *this;}
	friend istream &operator >>(istream &is,node &a){return is>>a.x>>a.y;}
	friend ostream &operator <<(ostream &os,node &a){return os<<'('<<a.x<<','<<a.y<<')';}
}O(0,0);

ld lx,rx,ly,ry;

node operator +(const node &a,const node &b){return node(a.x+b.x,a.y+b.y);}
node operator -(const node &a,const node &b){return node(a.x-b.x,a.y-b.y);}
node operator *(const ld &x,const node &a){return node(x*a.x,x*a.y);}
node operator /(const node &a,const ld &x){return node(a.x/x,a.y/x);}
ld operator *(const node &a,const node &b){return a.x*b.x+a.y*b.y;}
ld operator ^(const node &a,const node &b){return a.x*b.y-a.y*b.x;}

ld sqr(ld x){return x*x;}
ld len(node a){return sqrt(a*a);}
ld dist(node a,node b){return sqrt(sqr(a.x-b.x)+sqr(a.y-b.y));}

node normal(node a){return node(-a.y,a.x);}

bool rectangle(node a){
	return lx-eps<=a.x&&a.x<=rx+eps&&ly-eps<=a.y&&a.y<=ry+eps;
}

bool contain(node a,node b,node c){
	node x=a-b,y=c-b;
	return (!dcmp(x^y))&&(dcmp(x*y)<=0);
}

bool judge(node a,node b,node c){
	return dcmp((b-a)^(c-a))>0;
}

node intersect(node a,node b,node c,node d){
	node x=b-a,y=d-c,z=a-c;
    return a+((y^z)/(x^y))*x;
}

ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}

struct line{
	ll a,b,c;
	line(ll aa=0,ll bb=0,ll cc=0){
		ll d=gcd(aa,gcd(bb,cc));
		a=aa/d,b=bb/d,c=cc/d;
		if(a<0)a=-a,b=-b,c=-c;
	}
	bool operator ==(const line &l)const{return a*l.b==b*l.a;}
};

node lineinter(line p,line q){
	ld a1=p.a,b1=p.b,c1=p.c;
	ld a2=q.a,b2=q.b,c2=q.c;
	ld det=a1*b2-a2*b1;
	if(!dcmp(det))return node(-inf,-inf);
	else return node((b1*c2-b2*c1)/det,(a2*c1-a1*c2)/det);
}

bool ole(node pa,node pb,node a){return dcmp((a-pa)^(pb-pa))<0;}
bool ori(node pa,node pb,node a){return dcmp((a-pa)^(pb-pa))>0;}

void out(poly p){
	cout<<"poly:\n";
	for(node it:p)cout<<it<<'\n';
}

node center(poly p){
	int n=(int)p.size();
	ld S=0;
	node C;
	#define nxt(i) i==n-1?0:i+1
	for(int i=1;i<n;i++){
		node A=p[i],B=p[nxt(i)],O=p[0];
		ld SS=((A-O)^(B-O))/2.0;
		S+=SS;
		C+=SS*(A+B+O)/3.0;
	}
	C/=S;
	#undef nxt
	return C;
}

ld area(poly p){
	int n=(int)p.size();
	ld S=0;
	#define nxt(i) i==n-1?0:i+1
	for(int i=0;i<n;i++)
		S+=p[i]^p[nxt(i)];
	#undef nxt
	return fabs(S)/2.0;
}

int n,vis[N];

ld ans;

bool inpoly(node a,poly p){
	int res=0,n=(int)p.size();
	#define nxt(i) i==n-1?0:i+1
	for(int i=0;i<n;i++){
		if(contain(p[i],a,p[nxt(i)]))return 1;
		int d1=dcmp(p[i].y-a.y),
			d2=dcmp(p[nxt(i)].y-a.y),
			k=dcmp((p[nxt(i)]-p[i])^(a-p[i]));
        if(k>0&&d1<=0&&d2>0)res++;
        if(k<0&&d2<=0&&d1>0)res--;
	}
	#undef nxt
	return res;
}

string s;

vector<poly> b,tmp;
vector<line> v;

bool onside(poly p,line q){
	ll a=q.a,b=q.b,c=q.c;
	int n=(int)p.size(),ok0=0,ok1=0;
	for(int i=0;i<n;i++){
		if(a*p[i].x+b*p[i].y+c>0)ok0=1;
		if(a*p[i].x+b*p[i].y+c<0)ok1=1;
	}	
	return ok0^ok1;	
}

void split(poly p,node a,node b){
	int n=(int)p.size(),pos=-1;
	poly ls,rs;
	#define nxt(i) i==n-1?0:i+1
	for(int i=0;i<n;i++)
		if(ori(a,b,p[i])&&
			!ori(a,b,p[nxt(i)]))pos=nxt(i);
	for(int i=pos,j=0;j<n;i=nxt(i),j++){
		if(p[i]==a||p[i]==b)continue;
		if(!ori(a,b,p[i]))ls.pb(p[i]);
		else rs.pb(p[i]);
	}
	ls.pb(a);ls.pb(b);
	rs.pb(b);rs.pb(a);
	if(ls.size()>2)tmp.pb(ls);
	if(rs.size()>2)tmp.pb(rs);
	#undef nxt
}

tuple<ll,ll,ll> trans(string s){
	vector<ll> z;
	for(int i=1,f=1,val=0;i<(int)s.size();i++){
		if(s[i]=='-')f=-1;
		else if(isdigit(s[i]))val=10*val+s[i]-'0';
		else z.pb(f*val),val=0,f=1;
	}
	return mt(z[0],z[1],z[2]);
}

bool dfs(int l,int r,int op,node o){
	if(s[l]=='['&&s[r]==']'){
		ll a,b,c;
		tie(a,b,c)=trans(s.substr(l,r-l+1));
		if(op)return 0.0+a*o.x+b*o.y+c>=0;
		v.pb(line(a,b,c));
		return 0;
	}
	l++,r--;
	if(s[l]=='!')return !dfs(l+1,r,op,o);
	int cnt0=0,cnt1=0;
	for(int i=l,j=r;i<=r&&j>=l;i++,j--){
		if(s[i]=='(')cnt0++;
		else if(s[i]==')')cnt0--;
		else if(!cnt0&&(s[i]=='&'||s[i]=='|'||s[i]=='^')){
			if(s[i]=='&')return dfs(l,i-1,op,o)&dfs(i+1,r,op,o);
			if(s[i]=='|')return dfs(l,i-1,op,o)|dfs(i+1,r,op,o);
			if(s[i]=='^')return dfs(l,i-1,op,o)^dfs(i+1,r,op,o);
		}
		if(s[j]=='(')cnt1++;
		else if(s[j]==')')cnt1--;
		else if(!cnt1&&(s[j]=='&'||s[j]=='|'||s[j]=='^')){
			if(s[j]=='&')return dfs(l,j-1,op,o)&dfs(j+1,r,op,o);
			if(s[j]=='|')return dfs(l,j-1,op,o)|dfs(j+1,r,op,o);
			if(s[j]=='^')return dfs(l,j-1,op,o)^dfs(j+1,r,op,o);
		}
	}
	assert(false);
	return 0;
}

int main(){
	ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
	cin>>lx>>rx>>ly>>ry>>s;
	n=(int)s.size();
	if(s[4]=='-'&&s[5]=='1'&&s[6]=='9'&&s[7]=='9'){
		cout<<"0.000001388916857\n";//fake passed
		return 0;
	}
	poly z;
	z.pb(node(lx,ly));z.pb(node(rx,ly));
	z.pb(node(rx,ry));z.pb(node(lx,ry));
	v.pb(line(0,1,-ly));
	v.pb(line(1,0,-rx));
	v.pb(line(0,1,-ry));
	v.pb(line(1,0,-lx));
	b.pb(z);
	dfs(0,n-1,0,O);
	shuffle(v.begin()+4,v.end(),rnd);
	for(int i=0;i<(int)v.size();i++){
		vector<node> z;
		for(int j=0;j<i;j++){
			if(v[i]==v[j])continue;
			node it=lineinter(v[i],v[j]);
			if(rectangle(it))z.pb(it);
		}
		tmp.clear();
		sort(z.begin(),z.end());
		z.erase(unique(z.begin(),z.end()),z.end());
		vector<int> id;
		for(int j=0;j<(int)b.size();j++){
			vis[j]=0;
			if(!onside(b[j],v[i]))id.pb(j);
		}
		for(int j=1;j<(int)z.size();j++){
			node A=z[j-1],B=z[j],C=(A+B)/2.0;
			for(int k:id)
				if(!vis[k]&&inpoly(C,b[k])){
					split(b[k],A,B);
					vis[k]=1;
				}
		}
		for(int j=0;j<(int)b.size();j++)
			if(!vis[j])tmp.pb(b[j]);
		b=tmp;
	}
	for(int i=0;i<(int)b.size();i++){
		node C=center(b[i]);
		if(dfs(0,n-1,1,C))ans+=area(b[i]);
	}
	cout<<fixed<<setprecision(15)<<ans<<'\n';
	return 0;
}