#include "bits/stdc++.h"

#define all(x)   x.begin(), x.end()
#define NL       std::cout << '\n'

using lnt = long long;

const int inf = 0x3f3f3f3f;
const lnt linf = 1ll << 62;

using db = long double; const db eps = 1e-12;
int sgn(db x) { return (x < -eps ? -1 : x > eps); }

struct Pt { db x, y; };
std::istream& operator>>(std::istream& is, Pt &p) {
  int x, y; std::cin >> x >> y;
  p.x = x; p.y = y; return is;
}
std::ostream& operator<<(std::ostream& os, Pt p) {
	return os << "(" << p.x << "," << p.y << "),";
}

Pt operator-(Pt a, Pt b) { return { a.x - b.x, a.y - b.y }; }
Pt operator+(Pt a, Pt b) { return { a.x + b.x, a.y + b.y }; }
Pt operator*(Pt a, db x) { return { a.x * x, a.y * x }; }
Pt operator/(Pt a, db x) { return { a.x / x, a.y / x }; }
db dot(Pt a, Pt b) { return a.x * b.x + a.y * b.y; }
db det(Pt a, Pt b) { return a.x * b.y - a.y * b.x; }
bool operator==(Pt a, Pt b) { return !sgn(dot(a-b, a-b)); }
bool operator!=(Pt a, Pt b) { return sgn(dot(a-b, a-b)); }
bool operator<(Pt a, Pt b) { return a.x == b.x ? a.y < b.y : a.x < b.x; }
int side(Pt a, Pt b, Pt x) { return sgn(det(b-a, x-a)); }

struct Line { Pt s, t; };
Pt intersect(Line a, Line b) {
  db v = det(a.t - a.s, b.s - a.s);
  db u = det(a.t - a.s, b.t - a.s);
  return (b.s * u - b.t * v) / (u - v);
}
bool para(Line a, Line b) {
  return !sgn(det(a.t - a.s, b.t - b.s));
}

std::pair<std::vector<Pt>, std::vector<Pt>>
                            hullCut(std::vector<Pt> &hull, Line a) {
  int l = -1, r = -1; Pt il, ir;
  for (int i = hull.size() - 1, j = 0; j < hull.size(); i = j++) {
    auto &u = hull[i], &v = hull[j];
    int s1 = side(a.s, a.t, u), s2 = side(a.s, a.t, v);
    if (!s1 && !s2) { return {hull, {}}; }
    if (s1 * s2 <= 0) {
      if (l == -1) { l = j; il = intersect({u, v}, a); }
      else {
        Pt inter = intersect({u, v}, a);
        if (inter != il) { r = j; ir = inter; }
      }
    }
  }
  if (r == -1) { return { hull, {} }; }
  std::vector<Pt> lhs(hull.begin() + l, hull.begin() + r);
  if (lhs.empty() || ir != lhs.back()) { lhs.emplace_back(ir); }
  if (il != lhs.front()) { lhs.emplace_back(il);}
  std::vector<Pt> rhs(hull.begin() + r, hull.end());
  rhs.insert(rhs.end(), hull.begin(), hull.begin() + l);
  if (rhs.empty() || (il != rhs.back())) { rhs.emplace_back(il); }
  if (ir != rhs.front()) { rhs.emplace_back(ir); }
  return {lhs, rhs};
}

enum { ATOM = 128, AND, OR, XOR, NOT };

Pt polyCenter(std::vector<Pt> &v) {
  Pt ret {0, 0}; db s = 0;
  for (int j = 0, i = v.size() - 1; j < v.size(); i = j++) {
    ret = ret + (v[i] + v[j]) * det(v[i], v[j]);
    s += det(v[i], v[j]);
  }
  return ret / s / 3;
}

int main() {
  std::ios::sync_with_stdio(0), std::cin.tie(0);
  std::cout << std::fixed << std::setprecision(15);
  std::vector<std::vector<Pt>> polys(1);
  {
    int xmi, xmx, ymi, ymx; std::cin >> xmi >> xmx >> ymi >> ymx;
    polys[0].push_back({(db)xmi, (db)ymx});
    polys[0].push_back({(db)xmi, (db)ymi});
    polys[0].push_back({(db)xmx, (db)ymi});
    polys[0].push_back({(db)xmx, (db)ymx});
  }
  std::string raw; std::cin >> raw;

  Line tokenVal; int token;
  int p = 0;

  auto next = [&]() -> void {
    while (p != raw.size()) {
      token = raw[p++];
      if (token == '[') {
        static auto read = [&]() {
          int ret = 0; bool neg = 0;
          while (raw[p] == '-' || raw[p] == '+' || (raw[p] >= '0' && raw[p] <= '9')) {
            if (raw[p] == '-') { neg = !neg; }
            else if (raw[p] == '+') {  }
            else { ret = ret * 10 + raw[p] - '0'; }
            ++p;
          }
          if (neg) { ret = -ret; }
          return ret;
        };
        int a = read();
        ++p; // parse ','
        int b = read();
        ++p; // parse ','
        int cc = read();
        ++p; // parse ']'
        token = ATOM;
        if (b == 0) {
          tokenVal.s = { -1.L * cc / a, 0 };
          tokenVal.t = { -1.L * cc / a, (a > 0 ? -1. : 1.) };
        } else {
          tokenVal.s = { 0, -1.L * cc / b };
          tokenVal.t = tokenVal.s + Pt{ 1, -1.L * a / b };
        }
        if (b < 0) { std::swap(tokenVal.s, tokenVal.t); }
        return;
      } else if (token == '&') {
        token = AND; return;
      } else if (token == '|') {
        token = OR; return;
      } else if (token == '^') {
        token = XOR; return;
      } else if (token == '!') {
        token = NOT; return;
      } else if (token == '(' || token == ')') {
        return;
      }
    }
  };

  auto expr1 = [&](auto &self, int level) -> void {
    if (token == ATOM) {
      std::vector<std::vector<Pt>> npolys; npolys.reserve(polys.size() * 2);
      for (auto poly : polys) {
        auto [a, b] = hullCut(poly, tokenVal);
        npolys.emplace_back(a);
        if (!b.empty()) { npolys.emplace_back(b); }
      }
      std::swap(npolys, polys);
      next();
    } else if (token == '(') {
      next();
      self(self, ATOM);
      next();
    } else if (token == NOT) {
      next();
      self(self, NOT);
    }

    while (token >= level) {
      if (token == AND) {
        next(); self(self, NOT);
      } else if (token == OR) {
        next(); self(self, NOT);
      } else if (token == XOR) {
        next(); self(self, NOT);
      } else if (token == NOT) {
        next(); self(self, NOT);
      }
    }
  };

  next(); expr1(expr1, ATOM);

  std::vector<bool> stk;
  Pt ct;
  auto expr2 = [&](auto &self, int level) -> void {
    if (token == ATOM) {
      stk.emplace_back(side(tokenVal.s, tokenVal.t, ct) >= 0);
      next();
    } else if (token == '(') {
      next();
      self(self, ATOM);
      next();
    } else if (token == NOT) {
      next();
      self(self, NOT);
      stk.back() = !stk.back();
    }

    while (token >= level) {
      if (token == AND) {
        next(); self(self, NOT);
        bool a = stk.back(); stk.pop_back();
        bool b = stk.back(); stk.pop_back();
        stk.emplace_back(a & b);
      } else if (token == OR) {
        next(); self(self, NOT);
        bool a = stk.back(); stk.pop_back();
        bool b = stk.back(); stk.pop_back();
        stk.emplace_back(a | b);
      } else if (token == XOR) {
        next(); self(self, NOT);
        bool a = stk.back(); stk.pop_back();
        bool b = stk.back(); stk.pop_back();
        stk.emplace_back(a ^ b);
      }
    }
  };

  db ret = 0;
  for (auto poly : polys) {
    ct = polyCenter(poly);
    p = 0; next(); expr2(expr2, ATOM);
    if (stk.back()) {
      for (int i = poly.size() - 1, j = 0; j < poly.size(); i = j++) {
        ret += det(poly[i], poly[j]);
      }
    }
    stk.pop_back();
  }

  std::cout << ret / 2;
  return 0;
}