#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


using Double = long double;
const Double EPS = 1e-10L;
const Double INF = 1e+10L;
const Double PI = acos(-1.0L);
inline int sig(Double r) { return (r < -EPS) ? -1 : (r > +EPS) ? +1 : 0; }
inline Double sq(Double r) { return r * r; }

struct Pt {
  Double x, y;
  Pt() {}
  Pt(Double x_, Double y_) : x(x_), y(y_) {}
  Pt operator+(const Pt &a) const { return Pt(x + a.x, y + a.y); }
  Pt operator-(const Pt &a) const { return Pt(x - a.x, y - a.y); }
  Pt operator*(const Pt &a) const { return Pt(x * a.x - y * a.y, x * a.y + y * a.x); }
  Pt operator/(const Pt &a) const { const Double d2 = a.abs2(); return Pt((x * a.x + y * a.y) / d2, (y * a.x - x * a.y) / d2); }
  Pt operator+() const { return Pt(+x, +y); }
  Pt operator-() const { return Pt(-x, -y); }
  Pt operator*(const Double &k) const { return Pt(x * k, y * k); }
  Pt operator/(const Double &k) const { return Pt(x / k, y / k); }
  friend Pt operator*(const Double &k, const Pt &a) { return Pt(k * a.x, k * a.y); }
  Pt &operator+=(const Pt &a) { x += a.x; y += a.y; return *this; }
  Pt &operator-=(const Pt &a) { x -= a.x; y -= a.y; return *this; }
  Pt &operator*=(const Pt &a) { return *this = *this * a; }
  Pt &operator/=(const Pt &a) { return *this = *this / a; }
  Pt &operator*=(const Double &k) { x *= k; y *= k; return *this; }
  Pt &operator/=(const Double &k) { x /= k; y /= k; return *this; }
  Double abs() const { return sqrt(x * x + y * y); }
  Double abs2() const { return x * x + y * y; }
  Double arg() const { return atan2(y, x); }
  Double dot(const Pt &a) const { return x * a.x + y * a.y; }
  Double det(const Pt &a) const { return x * a.y - y * a.x; }
  friend ostream &operator<<(ostream &os, const Pt &a) { os << "(" << a.x << ", " << a.y << ")"; return os; }
};
inline Double tri(const Pt &a, const Pt &b, const Pt &c) { return (b - a).det(c - a); }

Pt pLL(const Pt &a, const Pt &b, const Pt &c, const Pt &d) {
  const Pt ab = b - a, cd = d - c;
  return a + ab * (c - a).det(cd) / ab.det(cd);
}

vector<Pt> convexCut(const vector<Pt> &ps, const Pt &a, const Pt &b) {
  const int n = ps.size();
  vector<Pt> ret;
  for (int i = 0; i < n; ++i) {
    if (sig(tri(a, b, ps[i])) >= 0) ret.push_back(ps[i]);
    if (sig(tri(a, b, ps[i])) * sig(tri(a, b, ps[(i + 1 == n) ? 0 : (i + 1)])) < 0) ret.push_back(pLL(a, b, ps[i], ps[(i + 1 == n) ? 0 : (i + 1)]));
  }
  if (ret.size() < 3) return {};
  return ret;
}


constexpr int LIM = 46'000;

Int X0, X1, Y0, Y1;
char S[10'010];

struct F {
  char op;
  int l, r;
  Int a, b, c;
  void print() {
    cerr << op << " " << l << " " << r << " " << a << " " << b << " " << c << endl;
  }
};
int N;
F fs[10010];

int cur;
void eat(char c) {
  assert(S[cur] == c);
  ++cur;
}
int formula();
int atomic();
int formula() {
  int ret;
  if (S[cur] == '(') {
    eat('(');
    if (S[cur] == '!') {
      eat('!');
      const int r = formula();
      eat(')');
      const int u = N++;
      fs[u] = F{'!', -1, r, 0, 0, 0};
      ret = u;
    } else {
      const int l = formula();
      const char op = S[cur++];
      const int r = formula();
      eat(')');
      const int u = N++;
      fs[u] = F{op, l, r, 0, 0, 0};
      ret = u;
    }
  } else {
    ret = atomic();
  }
  return ret;
}
int atomic() {
  int ret;
  eat('[');
  const int u = N++;
  fs[u] = F{'a', -1, -1, 0, 0, 0};
  sscanf(S + cur, "%lld,%lld,%lld", &fs[u].a, &fs[u].b, &fs[u].c);
  ret = u;
  for (; S[cur] != ']'; ++cur) {}
  eat(']');
  return ret;
}


vector<int> atoms;
int regsLen;
vector<pair<Pt, Double>> regs;
void dfs(int pos, const vector<Pt> &ps) {
  if (pos == (int)atoms.size()) {
    const int psLen = ps.size();
    Pt g(0.0L, 0.0L);
    Double area = 0.0L;
    for (int i = 0; i < psLen; ++i) {
      g += ps[i];
      area += ps[i].det(ps[(i + 1) % psLen]);
    }
    g /= psLen;
    area /= 2.0;
    regs.emplace_back(g, area);
  } else {
    const int u = atoms[pos];
    Pt s = fs[u].a ? Pt(-fs[u].c / (Double)fs[u].a, 0.0L) : Pt(0.0L, -fs[u].c / (Double)fs[u].b);
    Pt t = s + Pt(-fs[u].b, fs[u].a);
    for (int dir = 0; dir < 2; ++dir) {
      const auto qs = convexCut(ps, s, t);
      if (qs.size() >= 3) {
        dfs(pos + 1, qs);
      }
      swap(s, t);
    }
  }
}

int main() {
  for (; ~scanf("%lld%lld%lld%lld", &X0, &X1, &Y0, &Y1); ) {
    scanf("%s", S);
    
    cur = 0;
    N = 0;
    const int rt = formula();
// for(int u=0;u<N;++u)fs[u].print();
    
    atoms.clear();
    for (int u = 0; u < N; ++u) if (fs[u].op == 'a') {
      atoms.push_back(u);
    }
    regs.clear();
    vector<Pt> ini;
    ini.emplace_back(X0, Y0);
    ini.emplace_back(X1, Y0);
    ini.emplace_back(X1, Y1);
    ini.emplace_back(X0, Y1);
    dfs(0, ini);
    regsLen = regs.size();
// cerr<<"regs = "<<regs<<endl;
    
    assert(regsLen < LIM);
    bitset<LIM> all;
    for (int j = 0; j < regsLen; ++j) all.set(j);
    vector<bitset<LIM>> dp(N);
    for (int u = 0; u < N; ++u) {
      switch (fs[u].op) {
        case '&': {
          dp[u] = dp[fs[u].l] & dp[fs[u].r];
        } break;
        case '|': {
          dp[u] = dp[fs[u].l] | dp[fs[u].r];
        } break;
        case '^': {
          dp[u] = dp[fs[u].l] ^ dp[fs[u].r];
        } break;
        case '!': {
          dp[u] = all ^ dp[fs[u].r];
        } break;
        case 'a': {
          for (int j = 0; j < regsLen; ++j) {
            const Pt p = regs[j].first;
            if (fs[u].a * p.x + fs[u].b * p.y + fs[u].c >= 0) {
              dp[u].set(j);
            }
          }
        } break;
        default: assert(false);
      }
    }
    
    Double ans = 0.0;
    for (int j = 0; j < regsLen; ++j) if (dp[rt][j]) {
      ans += regs[j].second;
    }
    printf("%.12Lf\n", ans);
  }
  return 0;
}