#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
const double eps = 1e-9;
int Dcmp(double x) {
	return x < -eps ? -1 : x > eps ? 1 : 0;
}
struct Point {
	double x, y;
	Point(double x = 0, double y = 0) : x(x), y(y) {}
	Point operator + (Point rhs) {
		return Point(x + rhs.x, y + rhs.y);
	}
	Point operator - (Point rhs) {
		return Point(x - rhs.x, y - rhs.y);
	}
	double operator * (Point rhs) {
		return x * rhs.x + y * rhs.y;
	}
	double operator ^ (Point rhs) {
		return x * rhs.y - y * rhs.x;
	}
	Point operator * (double k) {
		return Point(x * k, y * k);
	}
	Point operator / (double k) {
		return Point(x / k, y / k);
	}
};
struct Line {
	Point s, t;
	Line(Point s = Point(), Point t = Point()) : s(s), t(t) {}
};
Line Convert(int a, int b, int c) {
	if(b == 0) {
		double x = 1. * -c / a;
		return Line(Point(x, 0), Point(x, 1));
	}
	return Line(Point(0, 1. * -c / b), Point(1, 1. * -(c + a) / b));
}
Point LineInter(Line l1, Line l2) {
	double a1 = (l2.t - l2.s) ^ (l1.s - l2.s), a2 = (l2.t - l2.s) ^ (l1.t - l2.s);
	return (l1.s * a2 - l1.t * a1) / (a2 - a1);
}
double Area(vector<Point> p) {
	double a = 0;
	int n = p.size();
	for(int i = 0; i < n; ++ i) {
		int j = (i + 1) % n;
		a += p[j] ^ p[i];
	}
	a = fabs(a);
	return a / 2;
}
int xl, xr, yl, yr, tot;
char s[maxn];
vector<vector<Point> > poly;
int Dir(int a, int b, int c, Point p) {
	return Dcmp(a * p.x + b * p.y + c);
}
void Cut(int a, int b, int c) {
	vector<vector<Point> > tmp;
	for(auto po : poly) {
		int n = po.size(), f1 = 0, f2 = 0;
		Point ex[2] = {Point(0, 0), Point(0, 0)};
		int now = 0;
		for(int i = 0; i < n; ++ i) {
			int j = (i + 1) % n;
			int d = Dir(a, b, c, po[i]);
			if(d == 1)
				f1 = 1;
			if(d == -1)
				f2 = 1;
			if(d == 0)
				ex[now ++] = po[i];
			else if(d * Dir(a, b, c, po[j]) == -1)
				ex[now ++] = LineInter(Convert(a, b, c), Line(po[i], po[j]));
		}
		if(!f1 || !f2)
			tmp.push_back(po);
		else {
			assert(now == 2);
			vector<Point> add[2] = {vector<Point>(), vector<Point>()};
			int w = 0, pos = 0, d = Dir(a, b, c, po[0]), beg = 0;
			if(d == 0) {
				add[w].push_back(ex[pos]);
				w ^= 1;
				add[w].push_back(ex[pos]);
				pos ++;
				d = Dir(a, b, c, po[1]);
				beg = 1;
			}
			for(int i = beg; i < n; ++ i) {
				int nowd = Dir(a, b, c, po[i]);
				if(nowd == d) {
					add[w].push_back(po[i]);
				}
				else {
					add[w].push_back(ex[pos]);
					w ^= 1;
					add[w].push_back(ex[pos]);
					pos ++;
					if(nowd == 0)
						d = Dir(a, b, c, po[(i + 1) % n]);
					else {
						add[w].push_back(po[i]);
						d = nowd;
					}
				}
			}
			if(pos < 2) {
				add[w].push_back(ex[pos]);
				w ^= 1;
				add[w].push_back(ex[pos]);
				pos ++;
			}
			assert(pos == 2);
			assert(add[0].size() >= 3u);
			assert(add[1].size() >= 3u);
			tmp.push_back(add[0]);
			tmp.push_back(add[1]);
		}
	}
	swap(tmp, poly);
}
int Get(int &pos) {
	int f = 1, num = 0;
	if(s[pos] == '-')
		f = -1, ++ pos;
	while(isdigit(s[pos]))
		num = num * 10 + s[pos] - '0', ++ pos;
	return f * num;
}
struct Node {
	int ls, rs, type, a, b, c;
	// type = 0: line, type = 1: &, type = 2: |, type = 3: ^, type = 4: !
	void SetLine(int _a, int _b, int _c) {
		type = 0;
		a = _a;
		b = _b;
		c = _c;
	}
	void SetOp(char c) {
		if(c == '&')
			type = 1;
		if(c == '|')
			type = 2;
		if(c == '^')
			type = 3;
		if(c == '!')
			type = 4;
	}
}nd[maxn];
int Calc(int u, Point p) {
	if(nd[u].type == 0)
		return Dir(nd[u].a, nd[u].b, nd[u].c, p) >= 0;
	if(nd[u].type == 1)
		return Calc(nd[u].ls, p) & Calc(nd[u].rs, p);
	if(nd[u].type == 2)
		return Calc(nd[u].ls, p) | Calc(nd[u].rs, p);
	if(nd[u].type == 3)
		return Calc(nd[u].ls, p) ^ Calc(nd[u].rs, p);
	if(nd[u].type == 4)
		return !Calc(nd[u].ls, p);
	assert(0);
}
int Solve(int l, int r) {
	int id = ++ tot;
	if(s[l] == '[') {
		assert(s[r] == ']');
		int pos = l + 1;
		int a = Get(pos);
		++ pos;
		int b = Get(pos);
		++ pos;
		int c = Get(pos);
		nd[id].SetLine(a, b, c);
		Cut(a, b, c);
	}
	else {
		int pos = l + 1;
		if(s[pos] == '!') {
			nd[id].SetOp(s[l + 1]);
			nd[id].ls = Solve(l + 2, r - 1);
		}
		else {
			if(s[pos] == '(') {
				if(s[pos] == '!')
					++ pos;
				int lay = 1;
				while(lay) {
					++ pos;
					if(s[pos] == '(')
						++ lay;
					if(s[pos] == ')')
						-- lay;
				}
				++ pos;
			}
			else if(s[pos] == '[') {
				while(s[pos] != ']')
					++ pos;
				++ pos;
			}
			nd[id].SetOp(s[pos]);
			nd[id].ls = Solve(l + 1, pos - 1);
			nd[id].rs = Solve(pos + 1, r - 1);
		}
	}
	return id;
}
int main() {
	scanf("%d%d%d%d", &xl, &xr, &yl, &yr);
	poly.push_back({Point(xl, yl), Point(xr, yl), Point(xr, yr), Point(xl, yr)});
	scanf("%s", s + 1);
	int len = strlen(s + 1);
	int rt = Solve(1, len);
	double ans = 0;
	for(auto po : poly) {
		Point now = Point();
		for(auto p : po)
			now = now + p;
		int s = po.size();
		now = now / s;
		if(Calc(rt, now))
			ans += Area(po);
	}
	printf("%.15f\n", ans);
}