#pragma GCC optimize("Ofast")
// #pragma GCC target("arch=skylake")

#include <bits/stdc++.h>
using namespace std;

#define all(x) begin(x), end(x)
#ifdef CKISEKI
#define safe cerr << __PRETTY_FUNCTION__ << " line " << __LINE__ << " safe\n"
#define debug(a...) debug_(#a, a)
#define orange(a...) orange_(#a, a)
#include <experimental/iterator>
void debug_(auto s, auto ...a) {
  cerr << "\e[1;32m(" << s << ") = (";
  int f = 0;
  (..., (cerr<< (f++ ? ", " : "") << a));
  cerr << ")\e[0m\n";
}
void orange_(auto s, auto L, auto R) {
  cerr << "\e[1;33m[ " << s << " ] = [ ";
  using namespace experimental;
  copy(L, R, make_ostream_joiner(cerr, ", "));
  cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define debug(...) safe
#define orange(...) safe
#endif

namespace {

#define IM imag
#define RE real

using lld = int64_t;
using llf = double;
using PF = complex<llf>;
using P = PF;

const llf eps = 1e-9;
int sgn(lld x) { return (x > 0) - (x < 0); }
int sgn(int x) { return (x > 0) - (x < 0); }
int sgn(llf x) { return (x > eps) - (x < -eps); }

llf cross(P a, P b) { return IM(conj(a) * b); }
int ori(P a, P b, P c) {
  return sgn(cross(b - a, c - a));
}

int quad(P p) {
  return (sgn(IM(p)) == 0)
    ? (sgn(RE(p)) < 0 ? 3 : 1) : (sgn(IM(p)) < 0 ? 0 : 2);
}
int argCmp(P a, P b) {
  int qa = quad(a), qb = quad(b);
  if (qa != qb) return sgn(qa - qb);
  return sgn(cross(b, a));
}

template <typename V> llf area(const V &pt) {
  llf ret = 0;
  for (int i = 1; i + 1 < (int)pt.size(); i++)
    ret += cross(pt[i] - pt[0], pt[i + 1] - pt[0]);
  return ret / 2.0;
}

struct Line {
  P st, ed, dir;
  Line (P s, P e) : st(s), ed(e), dir(e - s) {}
  Line rev() const {
    return Line(ed, st);
  }
};
using LN = const Line &;

PF intersect(LN A, LN B) {
  llf t = cross(B.st - A.st, B.dir) / llf(cross(A.dir, B.dir));
  return A.st + A.dir * t;
}

bool cov(LN l, LN A, LN B) {
  llf u = cross(B.st - A.st, B.dir);
  llf v = cross(A.dir, B.dir);

  llf x = RE(A.dir) * u + RE(A.st - l.st) * v;
  llf y = IM(A.dir) * u + IM(A.st - l.st) * v;
  return sgn(x * IM(l.dir) - y * RE(l.dir)) * sgn(v) >= 0;
}
bool operator<(LN a, LN b) {
  if (int c = argCmp(a.dir, b.dir)) return c == -1;
  return ori(a.st, a.ed, b.st) < 0;
}

bool HPI(vector<Line> &q, bool flag) {
  if (!flag) {
    sort(q.begin(), q.end());
  } else {
    auto l = q.back(); q.pop_back();
    auto it = lower_bound(q.begin(), q.end(), l);
    q.insert(it, l);
  }

  int n = (int)q.size(), l = 0, r = -1;
  for (int i = 0; i < n; i++) {
    if (i && !argCmp(q[i].dir, q[i-1].dir)) continue;
    while (l < r && cov(q[i], q[r-1], q[r])) --r;
    while (l < r && cov(q[i], q[l], q[l+1])) ++l;
    q[++r] = q[i];
  }
  while (l < r && cov(q[l], q[r-1], q[r])) --r;
  while (l < r && cov(q[r], q[l], q[l+1])) ++l;
  n = r - l + 1;
  if (n <= 1 || !argCmp(q[l].dir, q[r].dir)) {
    return false;
  }
  vector<PF> pt(n);
  for (int i = 0; i < n; i++)
    pt[i] = intersect(q[i + l], q[(i + 1) % n + l]);
  if (area(pt) < eps)
    return false;
  q = vector(q.begin() + l, q.begin() + r + 1);

  return true;
}

const int maxn = 50025;

struct node {
  node *lc, *rc;
  char op;
  int atomic_id;
  //~node() {
  //  delete lc;
  //  delete rc;
  //  lc = rc = 0;
  //}

  bitset<maxn> evaluate(const vector<bitset<maxn>> &s) {
    switch (op) {
      case '\0':
        return s[atomic_id];
      case '&':
        return lc->evaluate(s) & rc->evaluate(s);
      case '|':
        return lc->evaluate(s) | rc->evaluate(s);
      case '^':
        return lc->evaluate(s) ^ rc->evaluate(s);
      case '!':
        return ~lc->evaluate(s);
      default:
        __builtin_unreachable();
    }
  }
};

int atomid;
vector<Line> all_lines;

Line make_line(array<int, 3> v) {
  auto [a, b, c] = v;
  P dir(b, -a);
  P st(-c * a / llf(a * a + b * b), -c * b / llf(a * a + b * b));
  return Line(st, st + dir);
}

node *parse(const string &s, int &ptr) {
  array<int, 3> v;
  switch (s[ptr++]) {
    case '(':
    if (s[ptr] == '!') {
      ++ptr;
      node *lc = parse(s, ptr);
      assert(s[ptr++] == ')');
      if (lc->op == '!')
        return lc->lc;
      return new node(lc, nullptr, '!', -1);
    } else {
      node *lc = parse(s, ptr);
      char op = s[ptr++];
      node *rc = parse(s, ptr);
      assert(s[ptr++] == ')');
      return new node(lc, rc, op, -1);
    }

    case '[':
      for (int j = 0; j < 3; j++) {
        string decimal;
        while (s[ptr] != ',' && s[ptr] != ']') {
          decimal += s[ptr++];
        }
        v[j] = stoi(decimal);
        debug(v[j]);

        if (j < 2)
          assert(s[ptr++] == ',');
        else
          assert(s[ptr++] == ']');
      }
      all_lines.emplace_back(make_line(v));

      return new node(nullptr, nullptr, '\0', atomid++);

    default:
      __builtin_unreachable();
  };
  __builtin_unreachable();
}


struct Region {
  vector<P> p;
  bitset<500> value;
  // vector<int> value;
};

using P = PF;
vector<P> cut(const vector<P> &poly, P s, P e) {
  vector<P> res;
  for (size_t i = 0; i < poly.size(); i++) {
    P cur = poly[i], prv = i ? poly[i - 1] : poly.back();
    bool side = ori(s, e, cur) < 0;
    if (side != (ori(s, e, prv) < 0))
      res.push_back(intersect({s, e}, {cur, prv}));
    if (side)
      res.push_back(cur);
  }
  return res;
}

}

int main() {
  cin.tie(nullptr)->sync_with_stdio(false);

  int xmin, xmax, ymin, ymax;
  cin >> xmin >> xmax >> ymin >> ymax;

  string s;
  cin >> s;
  int ptr = 0;
  node *root = parse(s, ptr);


  vector<Region> regions;
  {
    // vector<Line> frame;
    bitset<500> v;
    const vector<P> p = {
      P(xmin, ymin), P(xmax, ymin), P(xmax, ymax), P(xmin, ymax)
    };
    // frame.emplace_back(P(xmin, 0), P(xmin, 0) + P(0, -1));
    // frame.emplace_back(P(0, ymin), P(0, ymin) + P(1, 0));
    // frame.emplace_back(P(xmax, 0), P(xmax, 0) + P(0, 1));
    // frame.emplace_back(P(0, ymax), P(0, ymax) + P(-1, 0));
    // assert(HPI(frame, false));
    // assert(frame.size() == 4);
    // regions.emplace_back(frame, v);
    regions.emplace_back(p, v);
  }

  for (int i = 0; i < atomid; i++) {
    auto ln = all_lines[i];
  // for (Line ln : all_lines) {

    P s = ln.st;
    P e = ln.ed;
    vector<Region> new_region;

    const auto old_size = regions.size();
    for (size_t x = 0; x < old_size; x++) {
      auto &r = regions[x];
      if (area(r.p) < eps) continue;
      bool pos = false, neg = false;
      orange(all(r.p));
      for (size_t j = 0; j < r.p.size(); j++) {
        int o = sgn( cross(r.p[j] - s, e - s) );
        // int o = ori(s, r.p[j], e);
        if (o > 0) pos = true;
        if (o < 0) neg = true;
        debug(o);
      }

      debug(pos, neg);
      if (pos && neg) {
        auto new_p = cut(r.p, e, s);
        orange(all(new_p));
        r.p = cut(r.p, s, e);
        auto new_val = r.value;
        new_val[i] = true;
        regions.emplace_back(new_p, new_val);
      } else {
        // assert(pos || neg);
        if (neg)
          r.value[i] = true;
      }
    }
    debug(regions.size());
  }


  /*
  debug(regions.size());
  for (const Region &r : regions) {
    orange(all(r.p));
    debug(r.value);
  }
  */

  vector<bitset<maxn>> mask(atomid);
  for (size_t i = 0; i < regions.size(); i++) {
    for (int j = 0; j < atomid; j++) {
      if (regions[i].value[j]) {
        mask[j][i] = true;
      }
    }
  }

  llf ans = 0;
  auto M = root->evaluate(mask);
  for (size_t i = 0; i < regions.size(); i++) {
    if (M[i]) {
      ans += area(regions[i].p);
    }
  }
  

  cout << fixed << setprecision(20);
  cout << ans << '\n';

  //delete root;

  return 0;
}