#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;

using ld = long double;

struct Vector {
    ld x;
    ld y;

    Vector(ld x = 0, ld y = 0): x(x), y(y) {}
    Vector(const Vector& u, const Vector& v): x(v.x - u.x), y(v.y - u.y) {}
};

const ld EPS = 1e-9;

struct Line {
    ld a;
    ld b;
    ld c;

    Line(ld a = 0, ld b = 0, ld c = 0): a(a), b(b), c(c) {}

    bool check(const Vector& v) const {
        return v.x * a + v.y * b + c >= -EPS;
    }
};

const int MAXN = 310;
Line ln[MAXN];
int id_l = 0;

const int MAXT = 1e4 + 100;
int tp[MAXT];
vector<int> ch[MAXT];
int id_tp = 0;

int nn() {
    return id_tp++;
}

int read_int(const string& s, int& l) {
    int res = 0;
    bool neg = false;
    if (s[l] == '-') {
        neg = true;
        ++l;
    }
    while (s[l] >= '0' && s[l] <= '9') {
        res = res * 10 + s[l] - '0';
        ++l;
    }
    if (neg) res = -res;
    return res;
}

set<char> op = {'&', '|', '^', '!'}; 
string str = "&|^!";

int get_tp(char ch) {
    for (int i = 0; i < (int)str.size(); ++i) {
        if (str[i] == ch) return -1 - i;
    }
    return 0;
}

int build(const string& s, int l, int r) {
    int v = nn();
    if (s[l] == '[') {
        ++l;
        ln[id_l].a = read_int(s, l);
        ++l;
        ln[id_l].b = read_int(s, l);
        ++l;
        ln[id_l].c = read_int(s, l);
        tp[v] = id_l++;
        return v;
    }
    int bal = 0;
    int ind = -1;
    for (int i = l + 1; i < r; ++i) {
        if (s[i] == '(') {
            ++bal;
        } else if (s[i] == ')') {
            --bal;
        } else if (bal == 0 && get_tp(s[i]) < 0) {
            ind = i;
            break;
        }
    }
    tp[v] = get_tp(s[ind]);
    if (ind != l + 1) {
        ch[v].push_back(build(s, l + 1, ind));
    }
    ch[v].push_back(build(s, ind + 1, r - 1));
    /// if (rand() % 2 == 0) swap(ch[v][0], ch.back());
    return v;
}

bool eval(int v, const Vector& a) {
    if (tp[v] >= 0) {
        return ln[tp[v]].check(a);
    }
    if (tp[v] == -4) {
        return !eval(ch[v][0], a);
    } else if (tp[v] == -1) {
        return eval(ch[v][0], a) && eval(ch[v][1], a);
    } else if (tp[v] == -2) {
        return eval(ch[v][0], a) || eval(ch[v][1], a);
    } else {
        return eval(ch[v][0], a) ^ eval(ch[v][1], a);
    }
}

Vector inter(const Line& l1, const Line& l2) {
    ld denom = l1.a * l2.b - l1.b * l2.a;
    return {(-l1.c * l2.b + l1.b * l2.c) / denom
          , (-l1.a * l2.c + l1.c * l2.a) / denom};
}

int inter_id[MAXN][MAXN];
Vector pts[MAXN * MAXN];
vector<int> online[MAXN];

struct HalfEdge {
    Vector dir;
    int to;
    int used;

    HalfEdge(Vector dir = Vector(), int to = -1): dir(dir), to(to), used(0) {}
};

const int MAXE = 2e6;
HalfEdge he[MAXE];
int id_he = 0;

vector<int> g[MAXN * MAXN];

ld operator*(const Vector& a, const Vector& b) {
    return a.x * b.x + a.y * b.y;
}

ld operator%(const Vector& a, const Vector& b) {
    return a.x * b.y - a.y * b.x;
}

Vector operator-(const Vector& a) {
    return {-a.x, -a.y};
}

bool hp(const Vector& v) {
    if (v.y == 0) return v.x > 0;
    return v.y > 0;
}

bool cmpv(const Vector& u, const Vector& v) {
    if (hp(u) != hp(v)) return hp(u);
    return u % v > 0;
}

bool cmp(int i, int j) {
    return cmpv(he[i].dir, he[j].dir);
}

int nxt(int i) {
    int v = he[i].to;
    Vector dir = -he[i].dir;
    HalfEdge tmp(dir, -1);
    he[id_he] = tmp;
    int res = upper_bound(g[v].begin(), g[v].end(), id_he, cmp) - g[v].begin();
    if (res == (int)g[v].size()) res = 0;
    return g[v][res];
}

ostream& operator<<(ostream& out, const Vector& v) {
    out << v.x << " " << v.y;
    return out;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);

    cout << fixed << setprecision(20);

    int xmn, xmx, ymn, ymx;
    cin >> xmn >> xmx >> ymn >> ymx;

    ln[id_l++] = {1, 0, -xmn};
    ln[id_l++] = {-1, 0, xmx};
    ln[id_l++] = {0, 1, -ymn};
    ln[id_l++] = {0, -1, ymx};

    string s;
    cin >> s;
    int root = build(s, 0, s.size());

    int n = id_l;
    /**for (int i = 0; i < n; ++i) {
        cerr << ln[i].a << " " << ln[i].b << " " << ln[i].c << endl;
    }*/
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            inter_id[i][j] = -1;
        }
    }
    int id_point = 0;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < i; ++j) {
            if (abs(ln[i].a * ln[j].b - ln[i].b * ln[j].a) < 0.5) {
                inter_id[i][j] = inter_id[j][i] = -1;
                continue;
            }
            Vector p = inter(ln[i], ln[j]);
            bool good = true;
            for (int i = 0; i < 4; ++i) {
                good &= ln[i].check(p);
            }
            /// cerr << i << " " << j << ": " << p << endl;
            if (!good) {
                inter_id[i][j] = inter_id[j][i] = -1;
                continue;
            }
            int ind = -1;
            for (int k = 0; k < i; ++k) {
                if (inter_id[k][j] != -1) {
                    Vector v = pts[inter_id[k][j]];
                    if (abs(v.x - p.x) < EPS && abs(v.y - p.y) < EPS) {
                        ind = inter_id[k][j];
                    }
                }
            }
            if (ind == -1) {
                /// cerr << i << "-" << j << endl;
                ind = id_point++;
            }
            /// cerr << i << " " << j << ": " << p << endl;
            pts[ind] = p;
            inter_id[i][j] = inter_id[j][i] = ind;
            online[i].push_back(ind);
            online[j].push_back(ind);
        }
    }
    int vert = id_point;

    for (int i = 0; i < n; ++i) {
        sort(online[i].begin(), online[i].end());
        online[i].resize(unique(online[i].begin(), online[i].end()) - online[i].begin());
        Vector dir = {-ln[i].b, ln[i].a};
        sort(online[i].begin(), online[i].end(), [&](int i, int j) { return pts[i] * dir < pts[j] * dir; });
        for (int j = 1; j < (int)online[i].size(); ++j) {
            int u = online[i][j], v = online[i][j - 1];
            /// cerr << u << " " << v << endl;
            he[id_he] = HalfEdge(dir, u);
            g[v].push_back(id_he++);
            he[id_he] = HalfEdge(-dir, v);
            g[u].push_back(id_he++);
        }
    }

    /// cerr << "points: ";
    /// cerr << vert << endl;
    for (int i = 0; i < vert; ++i) {
        sort(g[i].begin(), g[i].end(), cmp);
        /// cerr << pts[i] << endl;
    }


    /**for (int i : g[10]) {
        cerr << i << ": " << he[i].to << " " << he[i].dir << endl;
    }*/
    /// cerr << nxt(38) << endl;

    ld ans = 0;

    for (int i = 0; i < id_he; ++i) {
        if (he[i].used) continue;
        vector<Vector> face;
        int j = i;
        while (!he[j].used) {
            /// cerr << j << "; ";
            face.push_back(pts[he[j].to]);
            he[j].used = true;
            j = nxt(j);
        }
        /// cerr << endl;
        ld area = 0;
        for (int i = 0; i < face.size(); ++i) {
            area += (face[i] % face[(i + 1) % face.size()]);
            /// cout << face[i] << "; ";
        }
        /// cout << endl;
        /// cout << area << endl;
        if (area >= 0) continue;
        Vector s = Vector();
        for (int i = 0; i < face.size(); ++i) {
            s.x += face[i].x;
            s.y += face[i].y;
        }
        s.x /= face.size();
        s.y /= face.size();
        if (eval(root, s)) {
            ans -= area / 2;
        }
    }

    cout << ans << "\n";

    
    return 0;
}