#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef long double ld;
#define TIME (clock() * 1.0 / CLOCKS_PER_SEC)

// _________ vect (2D) ______________
template <typename T>
struct vect {
    T x = 0;
    T y = 0;

    vect() = default;
    vect(T x_, T y_) : x(x_), y(y_) {}

    inline T len2() const {
        return x * x + y * y;
    }

    inline ld len() const {
        return sqrtl(len2());
    }

    inline vect rotate() const {
        return vect(-y, x);
    }
};

template <typename T>
inline istream& operator>>(istream& in, vect<T>& v) {
    return in >> v.x >> v.y;
}

template <typename T>
inline ostream& operator<<(ostream& out, const vect<T>& v) {
    return out << "[" << v.x << "," << v.y << "]";
}

template <typename T>
inline vect<T> operator+(const vect<T>& a, const vect<T>& b) {
    return vect<T>(a.x + b.x, a.y + b.y);
}

template <typename T>
inline vect<T> operator-(const vect<T>& a, const vect<T>& b) {
    return vect<T>(a.x - b.x, a.y - b.y);
}

template <typename T>
inline vect<T> operator*(const vect<T>& a, T k) {
    return vect<T>(a.x * k, a.y * k);
}

template <typename T>
inline T operator*(const vect<T>& a, const vect<T>& b) {
    return a.x * b.x + a.y * b.y;
}

template <typename T>
inline T operator^(const vect<T>& a, const vect<T>& b) {
    return a.x * b.y - a.y * b.x;
}

// _________ line (2D) ______________
template <typename T>
struct line {
    T a = 0;
    T b = 0;
    T c = 0;

    line() = default;
    line(T a_, T b_, T c_) : a(a_), b(b_), c(c_) {}
    line(const vect<T>& p, const vect<T>& dir) : a(-dir.y), b(dir.x), c(-(dir ^ p)) {}

    inline vect<T> normal() const {
        return vect<T>(a, b);
    }

    inline T calc(const vect<T>& pt) const {
        return a * pt.x + b * pt.y + c;
    }
};

template <typename T>
inline istream& operator>>(istream& in, line<T>& l) {
    return in >> l.a >> l.b >> l.c;
}

template <typename T>
inline ostream& operator<<(ostream& out, const line<T>& l) {
    //return out << l.a << "*x+" << l.b << "*y+" << l.c << "=0";
    return out << l.a << " " << l.b << " " << l.c;
}

template <typename T>
inline line<T> linePoints(const vect<T>& A, const vect<T>& B) {
    return line<T>(A, B - A);
}

template <typename T>
vect<ld> intersection(const line<T>& l1, const line<T>& l2) {
    auto pr = l1.a * l2.b - l1.b * l2.a;
    assert(abs(pr) > 1e-10);
    auto prx = l1.b * l2.c - l1.c * l2.b;
    auto pry = l1.c * l2.a - l1.a * l2.c;
    return vect<ld>((ld)prx / pr, (ld)pry / pr);
}

vector<line<ld>> lines;

struct Node {
    Node* l, *r;
    int tp; // -1 -> line ; 0 -> & ; 1 -> | ; 2 -> ^ ; 3 -> !
    int idx;

    Node(Node* l, Node* r, int tp, int idx) : l(l), r(r), tp(tp), idx(idx) {}

    bool calculate(const vect<ld>& p) {
        if (tp == -1) {
            return lines[idx].calc(p) >= 0;
        }
        if (tp == 0) {
            return l->calculate(p) && r->calculate(p);
        }
        if (tp == 1) {
            return l->calculate(p) || r->calculate(p);
        }
        if (tp == 2) {
            return l->calculate(p) ^ r->calculate(p);
        }
        if (tp == 3) {
            return !l->calculate(p);
        }
        assert(false);
    }
};

string s;

line<ld> find_line(int l, int r) {
    vector<int> pos;
    for (int i = l; i < r; i++) {
        if (s[i] == ',') {
            pos.emplace_back(i);
        }
    }
    assert(pos.size() == 2);
    line<ld> res;
    res.a = stoi(s.substr(l + 1, pos[0] - l - 1));
    res.b = stoi(s.substr(pos[0] + 1, pos[1] - pos[0] - 1));
    res.c = stoi(s.substr(pos[1] + 1, r - pos[1] - 1));
    return res;
}

Node* construct(int l, int r) {
    //cerr << "go " << s.substr(l, r - l) << "\n";
    if (s[l] == '[') {
        auto line = find_line(l, r);
        lines.emplace_back(line);
        return new Node(nullptr, nullptr, -1, (int)lines.size() - 1);
    }
    assert(s[l] == '(' && s[r - 1] == ')');
    if (s[l + 1] == '!') {
        return new Node(
            construct(l + 2, r - 1),
            nullptr,
            3,
            -1
        );
    }
    int bal = 0;
    int p = -1;
    for (int i = l + 1; i < r - 1; i++) {
        if (s[i] == '(') {
            bal++;
        } else if (s[i] == ')') {
            bal--;
        }
        if (bal == 0 && (s[i] == '&' || s[i] == '|' || s[i] == '^')) {
            p = i;
            break;
        }
    }
    assert(p != -1);
    int tp;
    if (s[p] == '&') {
        tp = 0;
    } else if (s[p] == '|') {
        tp = 1;
    } else {
        tp = 2;
    }
    return new Node(
         construct(l + 1, p),
         construct(p + 1, r - 1),
         tp,
         -1
    );
}

const ld eps = 1e-8;

struct Polygon {
    vector<vect<ld>> pt;
    vector<line<ld>> lines;

    Polygon(const vector<vect<ld>>& pt, const vector<line<ld>>& lines) : pt(pt), lines(lines) {}

    bool is_sep(const line<ld>& line) const {
        ld mx = -1e18;
        ld mn = 1e18;
        for (const auto& p : pt) {
            auto val = line.calc(p);
            mn = min(mn, val);
            mx = max(mx, val);
        }
        if (mn >= -eps) {
            return false;
        }
        if (mx <= eps) {
            return false;
        }
        return true;
    }
};

ostream& operator<<(ostream& out, const Polygon& poly) {
    out << "Polygon\n";
    for (const auto& p : poly.pt) {
        out << p.x << " " << p.y << "\n";
    }
    out << "...";
    return out;
}

Polygon get_rect(int xmin, int xmax, int ymin, int ymax) {
    vector<vect<ld>> pt;
    pt.emplace_back(xmin, ymin);
    pt.emplace_back(xmax, ymin);
    pt.emplace_back(xmax, ymax);
    pt.emplace_back(xmin, ymax);
    vector<line<ld>> ln;
    ln.emplace_back(0.0, 1.0, -ymin);
    ln.emplace_back(-1.0, 0.0, xmax);
    ln.emplace_back(0.0, -1.0, ymax);
    ln.emplace_back(1.0, 0.0, -xmin);
    return Polygon(pt, ln);
}

void sep(const Polygon& poly, const line<ld>& line, vector<Polygon>& into) {
    const auto& pt = poly.pt;
    int n = pt.size();
    vector<ld> vals(n);
    for (int i = 0; i < n; i++) {
        vals[i] = line.calc(pt[i]);
    }
    for (int i = 0; i < n; i++) {
        if (abs(vals[i]) < eps || (vals[i] <= -eps && vals[(i + 1) % n] >= eps) || (vals[i] >= eps && vals[(i + 1) % n] <= -eps)) {

            auto st = pt[i];
            if (abs(vals[i]) >= eps) {
                st = intersection(poly.lines[i], line);
            }

            int best = -1;
            ld bd = -1e18;
            for (int j = i + 1; j != i; j = (j + 1) % n) {
                if (abs(vals[j]) < eps || (vals[j] <= -eps && vals[(j + 1) % n] >= eps) || (vals[j] >= eps && vals[(j + 1) % n] <= -eps)) {
                    ld cur = (pt[j] - st).len2();
                    if (cur > bd) {
                        best = j;
                        bd = cur;
                    }
                }
            }

            assert(best != -1);
            int j = best;

            auto fn = pt[j];
            if (abs(vals[j]) >= eps) {
                fn = intersection(poly.lines[j], line);
            }

            {
                vector<vect<ld>> now_pt;
                vector<::line<ld>> now_lines;

                now_pt.emplace_back(st);
                now_lines.emplace_back(poly.lines[i]);
                for (int x = i; x != j; x = (x + 1) % n) {
                    now_pt.emplace_back(pt[(x + 1) % n]);
                    now_lines.emplace_back(poly.lines[(x + 1) % n]);
                }
                now_pt.emplace_back(fn);
                now_lines.emplace_back(line);

                into.emplace_back(now_pt, now_lines);
            }

            {
                vector<vect<ld>> now_pt;
                vector<::line<ld>> now_lines;

                swap(fn, st);
                swap(i, j);

                now_pt.emplace_back(st);
                now_lines.emplace_back(poly.lines[i]);
                for (int x = i; x != j; x = (x + 1) % n) {
                    now_pt.emplace_back(pt[(x + 1) % n]);
                    now_lines.emplace_back(poly.lines[(x + 1) % n]);
                }
                now_pt.emplace_back(fn);
                now_lines.emplace_back(line);

                into.emplace_back(now_pt, now_lines);
            }

            break;
        }
    }
}

void solve() {
    int xmin, xmax, ymin, ymax;
    cin >> xmin >> xmax >> ymin >> ymax;
    cin >> s;
    auto f = construct(0, s.size());

    vector<Polygon> polygons;
    polygons.emplace_back(get_rect(xmin, xmax, ymin, ymax));

    for (const auto& line : lines) {
        /*for (const auto& poly : polygons) {
            cout << poly << "\n";
        }
        cout << string(100, '-') << "\n";*/

        vector<Polygon> nw;
        for (const auto& poly : polygons) {
            if (poly.is_sep(line)) {
                sep(poly, line, nw);
            } else {
                nw.emplace_back(poly);
            }
        }

        swap(polygons, nw);
    }

    /*for (const auto& poly : polygons) {
        cout << poly << "\n";
    }*/

    ld ans = 0.0;
    for (const auto& poly : polygons) {
        vect<ld> sm(0, 0);
        for (const auto& p : poly.pt) {
            sm = sm + p;
        }
        sm.x /= poly.pt.size();
        sm.y /= poly.pt.size();
        if (f->calculate(sm)) {
            ld area = 0.0;
            for (int i = 0; i < (int)poly.pt.size(); ++i) {
                area += (poly.pt[i] ^ poly.pt[(i + 1) % (int)poly.pt.size()]);
            }
            ans += abs(area) / 2.0;
        }
    }

    cout << ans << "\n";
}

int main() {
#ifdef ONPC
    freopen("input", "r", stdin);
#endif
    ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);

    cout << fixed << setprecision(20);

    int t = 1;
    //cin >> t;
    while (t--) {
        solve();
    }

    return 0;
}