#include <bits/stdc++.h>
using namespace std;
#define ldb double
#define ll long long
#define pb push_back

struct pt{
	ldb x,y;
	pt():x(0),y(0){}
	pt(ldb a,ldb b):x(a),y(b){}
};

pt operator + (pt a,pt b){return pt(a.x+b.x,a.y+b.y);}
pt operator - (pt a,pt b){return pt(a.x-b.x,a.y-b.y);}
pt operator * (pt a,ldb b){return pt(a.x*b,a.y*b);}
pt operator / (pt a,ldb b){return pt(a.x/b,a.y/b);}

ldb dot(pt a,pt b){return a.x*b.x+a.y*b.y;}
ldb cross(pt a,pt b){return a.x*b.y-a.y*b.x;}

struct line{
	pt v;
	ldb c;

	line(pt a,pt b){
		v=b-a;
		c=cross(v,a);
	}

	line(ldb a,ldb b,ldb _c){
		v=pt(b,-a);
		c=-_c;
	}

	bool in_order(pt P, pt Q, pt R){
		ldb p=dot(P,v);
		ldb q=dot(Q,v);
		ldb r=dot(R,v);
		return p<q && q<=r;
	}
};

bool paralel(line a,line b){
	return cross(a.v,b.v)==0;
}

pt inter(line a,line b){
	pt ans=(a.v*b.c-b.v*a.c)/cross(b.v,a.v);
	return ans;
}

struct expr{
	virtual bool check(pt p) = 0;
};

struct func : public expr{
	ll a,b,c;

	func(ll x,ll y,ll z):a(x),b(y),c(z){}

	ldb eval(pt p){
		return a*p.x+b*p.y+c;
	}

	bool check(pt p) override {
		return eval(p)>=0;
	}
};

struct op : public expr{
	char o;
	expr* l;
	expr* r;

	op(char _o, expr* _l, expr* _r=nullptr):o(_o),l(_l),r(_r){}

	bool check(pt p) override {
		if(o=='!')return !l->check(p);
		else if(o=='&')return l->check(p) && r->check(p);
		else if(o=='|')return l->check(p) || r->check(p);
		else if(o=='^')return l->check(p) ^ r->check(p);
		return false;
	}
};

string s;

int Find(int from,char c){
	while(s[from]!=c)from++;
	return from;
}

vector<line> lines;

expr* Parse(int l,int r){
	if(s[l]=='['){
		int ptr=Find(l+1,',');
		ll a=stoi(s.substr(l+1,ptr-l-1));
		l=ptr;
		ptr=Find(l+1,',');
		ll b=stoi(s.substr(l+1,ptr-l-1));
		l=ptr;
		ptr=Find(l+1,']');
		ll c=stoi(s.substr(l+1,ptr-l-1));
		lines.pb(line(a,b,c));
		return new func(a,b,c);
	}
	int bal=0;
	for(int i=l;i<=r;i++){
		if(s[i]=='(')bal++;
		if(s[i]==')')bal--;
		if(bal==1 && (s[i]=='!' || s[i]=='^' || s[i]=='&' || s[i]=='|')){
			if(s[i]=='!'){
				return new op(s[i], Parse(i+1,r-1));
			}else{
				return new op(s[i], Parse(l+1,i-1), Parse(i+1,r-1));
			}
		}
	}
}

ldb area(pt a,pt b,pt c){
	ldb ans=cross(a,b)+cross(b,c)+cross(c,a);
	return abs(ans)/2;
}

ldb area(vector<pt> poly){
	ldb ans=0;
	for(int i=0;i<poly.size();i++){
		int j=(i+1)%poly.size();
		ans+=cross(poly[i],poly[j]);
	}
	return abs(ans)/2;
}

pt GetCentroid(vector<pt> poly){
	pt ans(0,0);
	ldb q=0;
	for(int i=0;i<poly.size();i++){
		int j=(i+1)%poly.size();
		ldb cr=cross(poly[i],poly[j]);
		ans=ans+(poly[i]+poly[j])/3*cr;
		q+=cr;
	}
	return ans/q;
}

const ldb eps=1e-9;
vector<pt> Clean(vector<pt> poly){
	vector<pt> ans;
	for(int i=0;i<poly.size();i++){
		int j=(i+1)%poly.size();
		pt diff=poly[i]-poly[j];
		if(abs(diff.x)<eps && abs(diff.y)<eps){
			continue;
		}
		ans.pb(poly[i]);
	}
	return ans;
}

vector<vector<pt>> newPolys;
void Split(vector<pt> poly, line a){
	vector<pair<int,pt>> sec;
	for(int i=0;i<poly.size();i++){
		int j=(i+1)%poly.size();
		line b=line(poly[i],poly[j]);
		if(paralel(a,b))continue;
		pt g=inter(a,b);
		if(b.in_order(poly[i],g,poly[j])){
			sec.pb({i,g});
		}
	}
	if(sec.size()<2){
		newPolys.pb(poly);
	}else if(sec.size()==2){
		int l=sec[0].first;
		int r=sec[1].first;
		vector<pt> A;
		A.pb(sec[0].second);
		for(int i=(l+1)%poly.size();i!=(r+1)%poly.size();i=(i+1)%poly.size()){
			A.pb(poly[i]);
		}
		A.pb(sec[1].second);
		newPolys.pb(Clean(A));
		vector<pt> B;
		B.pb(sec[1].second);
		for(int i=(r+1)%poly.size();i!=(l+1)%poly.size();i=(i+1)%poly.size()){
			B.pb(poly[i]);
		}
		B.pb(sec[0].second);
		newPolys.pb(Clean(B));
	}else{
		printf("%i\n",sec.size());
		for(int i=0;i<sec.size();i++)printf("%i %.2lf %.2lf\n",sec[i].first,sec[i].second.x,sec[i].second.y);
		for(pt p:poly)printf("(%.2lf, %.2lf)\n",p.x,p.y);
		exit(0);
	}
}

int main(){
	int xl,xr,yl,yr;
	scanf("%i %i %i %i",&xl,&xr,&yl,&yr);
	cin>>s;
	expr* e=Parse(0,s.size()-1);
	//lines.pb(line(pt(xl,yl),pt(xl,yr)));
	//lines.pb(line(pt(xl,yl),pt(xr,yl)));
	//lines.pb(line(pt(xr,yr),pt(xl,yr)));
	//lines.pb(line(pt(xr,yr),pt(xr,yl)));

	vector<vector<pt>> polys={{
		pt(xl,yl),
		pt(xl,yr),
		pt(xr,yr),
		pt(xr,yl)
	}};

	for(line a:lines){
		newPolys.clear();
		for(vector<pt> poly:polys){
			Split(poly, a);
		}
		polys=newPolys;
		/*printf("Polys:\n");
		for(vector<pt> poly:polys){
			for(pt p:poly)printf("(%.2lf %.2lf) ",p.x,p.y);
			printf("\n");
		}*/
	}

	/*vector<pt> pts;
	for(line a:lines){
		for(line b:lines){
			if(!paralel(a,b)){
				pts.pb(inter(a,b));
			}
		}
	}*/

	ldb ans=0;

	ldb totalArea=0;
	for(vector<pt> poly: polys){
		pt cen=GetCentroid(poly);
		//printf("Cen (%.2lf, %.2lf) %.2lf\n",cen.x,cen.y,area(poly));
		//totalArea+=area(poly);
		if(e->check(cen)){
			//printf("Take\n");
			ans+=area(poly);
		}
	}

	//printf("total area: %.2lf (%i)\n",totalArea,(xr-xl)*(yr-yl));
	/*vector<array<pt,3>> triangles=Triangulate(pts);
	for(auto tr:triangles){
		pt cen=(tr[0]+tr[1]+tr[2])/3;
		if(cen.x>=xl && cen.x<=xr && cen.y>=yl && cen.y<=yr){
			if(e->check(cen)){
				ans+=area(tr[0],tr[1],tr[2]);
			}
		}
	}*/

	cout << fixed << setprecision(12) << ans << std::endl;

	return 0;
}