#include <bits/stdc++.h>
using namespace std;
struct frac{
  long long num, den;
  frac(){
  }
  frac(long long num_, long long den_ = 1){
    num = num_;
    den = den_;
    if (den < 0){
      num *= -1;
      den *= -1;
    }
  }
  bool operator ==(frac x){
    return num * x.den == x.num * den;
  }
  bool operator <(frac x){
    return num * x.den < x.num * den;
  }
  bool operator <=(frac x){
    return num * x.den <= x.num * den;
  }
  frac operator -(frac x){
    return frac(num * x.den - x.num * den, den * x.den);
  }
  double value(){
    return (double) num / den;
  }
};
struct point{
  frac x, y;
  point(){
  }
  point(frac x, frac y): x(x), y(y){
  }
  bool operator ==(point P){
    return x == P.x && y == P.y;
  }
  bool operator <(point P){
    return x < P.x || x == P.x && y < P.y;
  }
};
struct line{
  long long a, b, c;
  line(long long a, long long b, long long c): a(a), b(b), c(c){
  }
};
bool is_parallel(line L1, line L2){
  return L1.a * L2.b - L1.b * L2.a == 0;
}
point line_intersection(line L1, line L2){
  long long det = L1.a * L2.b - L1.b * L2.a;
  long long x = (-L1.c) * L2.b - L1.b * (-L2.c);
  long long y = L1.a * (-L2.c) - (-L1.c) * L2.a;
  return point(frac(x, det), frac(y, det));
}
int main(){
  cout << fixed << setprecision(20);
  int xmin, xmax, ymin, ymax;
  cin >> xmin >> xmax >> ymin >> ymax;
  string S;
  cin >> S;
  int V = 1;
  vector<string> T(V);
  vector<vector<int>> c(V);
  vector<line> L;
  L.push_back(line(1, 0, -xmin));
  L.push_back(line(-1, 0, xmax));
  L.push_back(line(0, 1, -ymin));
  L.push_back(line(0, -1, ymax));
  int p = 0;
  auto add_vertex = [&](){
    T.push_back("");
    c.push_back(vector<int>(0));
    V++;
  };
  auto number = [&]() -> int {
    int ans = 0;
    bool neg = false;
    if (S[p] == '-'){
      neg = true;
      p++;
    }
    while (isdigit(S[p]) != 0){
      ans = ans * 10 + (S[p] - '0');
      p++;
    }
    if (neg){
      ans *= -1;
    }
    return ans;
  };
  auto dfs = [&](auto dfs, int v, int pr = -1) -> void {
    if (S[p] == '['){
      T[v] = "L" + to_string(L.size());
      p++;
      long long a = number();
      p++;
      long long b = number();
      p++;
      long long c = number();
      p++;
      L.push_back(line(a, b, c));
    } else {
      p++;
      if (S[p] == '!'){
        if (pr == -1){
          T[v] = "!";
          p++;
          c[v].push_back(V);
          add_vertex();
          dfs(dfs, V - 1, v);
        } else {
          T.pop_back();
          p++;
          c.pop_back();
          c[pr].pop_back();
          V--;
          dfs(dfs, pr, -1);
        }
      } else {
        c[v].push_back(V);
        add_vertex();
        dfs(dfs, V - 1, -1);
        T[v] = S[p];
        p++;
        c[v].push_back(V);
        add_vertex();
        dfs(dfs, V - 1, -1);
      }
      p++;
    }
  };
  dfs(dfs, 0);
  int N = L.size();
  vector<point> P;
  for (int i = 0; i < N; i++){
    for (int j = i + 1; j < N; j++){
      if (!is_parallel(L[i], L[j])){
        point T = line_intersection(L[i], L[j]);
        if (frac(xmin) <= T.x && T.x <= frac(xmax) && frac(ymin) <= T.y && T.y <= frac(ymax)){
          P.push_back(T);
        }
      }
    }
  }
  sort(P.begin(), P.end());
  P.erase(unique(P.begin(), P.end()), P.end());
  int M = P.size();
  vector<frac> X;
  for (int i = 0; i < M; i++){
    X.push_back(P[i].x);
  }
  X.erase(unique(X.begin(), X.end()), X.end());
  int Xcnt = X.size();
  vector<int> left(N, Xcnt), right(N, 0);
  for (int i = 0; i < N; i++){
    for (int j = 0; j < N; j++){
      if (!is_parallel(L[i], L[j])){
        point T = line_intersection(L[i], L[j]);
        if (frac(xmin) <= T.x && T.x <= frac(xmax) && frac(ymin) <= T.y && T.y <= frac(ymax)){
          int idx = lower_bound(X.begin(), X.end(), T.x) - X.begin();
          left[i] = min(left[i], idx);
          right[i] = max(right[i], idx);
        }
      }
    }
  }
  vector<vector<frac>> Y(Xcnt);
  for (int i = 0; i < N; i++){
    if (L[i].b != 0){
      for (int j = left[i]; j <= right[i]; j++){
        Y[j].push_back(frac(-L[i].c * X[j].den - L[i].a * X[j].num, L[i].b * X[j].den));
      }
    }
  }
  for (int i = 0; i < Xcnt; i++){
    sort(Y[i].begin(), Y[i].end());
    Y[i].erase(unique(Y[i].begin(), Y[i].end()), Y[i].end());
  }
  vector<vector<int>> pos(N, vector<int>(Xcnt, -1));
  for (int i = 0; i < N; i++){
    if (L[i].b != 0){
      for (int j = left[i]; j <= right[i]; j++){
        frac y(-L[i].c * X[j].den - L[i].a * X[j].num, L[i].b * X[j].den);
        pos[i][j] = lower_bound(Y[j].begin(), Y[j].end(), y) - Y[j].begin();
      }
    }
  }
  vector<vector<pair<int, int>>> E(Xcnt - 1);
  for (int i = 0; i < N; i++){
    if (L[i].b != 0){
      for (int j = left[i]; j < right[i]; j++){
        E[j].push_back(make_pair(pos[i][j], pos[i][j + 1]));
      }
    }
  }
  for (int i = 0; i < Xcnt - 1; i++){
    sort(E[i].begin(), E[i].end());
    E[i].erase(unique(E[i].begin(), E[i].end()), E[i].end());
  }
  vector<vector<int>> idx_V(Xcnt - 2);
  for (int i = 0; i < N; i++){
    if (L[i].b == 0){
      frac x(-L[i].c, L[i].a);
      if (frac(xmin) < x && x < frac(xmax)){
        int idx = lower_bound(X.begin(), X.end(), x) - X.begin();
        idx_V[idx - 1].push_back(i);
      }
    }
  }
  vector<int> sum(Xcnt);
  sum[0] = 0;
  for (int i = 0; i < Xcnt - 1; i++){
    sum[i + 1] = sum[i] + E[i].size() - 1;
  }
  int V2 = sum[Xcnt - 1];
  vector<double> area(V2, 0);
  vector<double> px(V2, 0), py(V2, 0);
  for (int i = 0; i < Xcnt - 1; i++){
    for (int j = 0; j < E[i].size() - 1; j++){
      double dl = (Y[i][E[i][j + 1].first] - Y[i][E[i][j].first]).value();
      double dr = (Y[i + 1][E[i][j + 1].second] - Y[i + 1][E[i][j].second]).value();
      double h = (X[i + 1] - X[i]).value();
      area[sum[i] + j] = (dl + dr) * h / 2;
      px[sum[i] + j] = (X[i].value() + X[i + 1].value()) / 2;
      py[sum[i] + j] += Y[i][E[i][j].first].value();
      py[sum[i] + j] += Y[i][E[i][j + 1].first].value();
      py[sum[i] + j] += Y[i + 1][E[i][j].second].value();
      py[sum[i] + j] += Y[i + 1][E[i][j + 1].second].value();
      py[sum[i] + j] /= 4;
    }
  }
  vector<vector<int>> idx_L(Xcnt - 1), idx_R(Xcnt - 1);
  for (int i = 0; i < Xcnt - 1; i++){
    idx_L[i].resize(Y[i].size() - 1);
    idx_R[i].resize(Y[i + 1].size() - 1);
    int Ecnt = E[i].size();
    for (int j = 0; j < Ecnt - 1; j++){
      for (int k = E[i][j].first; k < E[i][j + 1].first; k++){
        idx_L[i][k] = sum[i] + j;
      }
      for (int k = E[i][j].second; k < E[i][j + 1].second; k++){
        idx_R[i][k] = sum[i] + j;
      }
    }
  }
  vector<vector<int>> E2(V2);
  for (int i = 1; i < Xcnt - 1; i++){
    if (idx_V[i - 1].empty()){
      for (int j = 0; j < Y[i].size() - 1; j++){
        E2[idx_R[i - 1][j]].push_back(idx_L[i][j]);
        E2[idx_L[i][j]].push_back(idx_R[i - 1][j]);
      }
    }
  }
  vector<int> cc(V2, -1);
  int cc_cnt = 0;
  vector<bool> head(V2, false);
  for (int i = 0; i < V2; i++){
    if (cc[i] == -1){
      cc[i] = cc_cnt;
      head[i] = true;
      queue<int> Q;
      Q.push(i);
      while (!Q.empty()){
        int v = Q.front();
        Q.pop();
        for (int w : E2[v]){
          if (cc[w] == -1){
            cc[w] = cc[v];
            Q.push(w);
          }
        }
      }
      cc_cnt++;
    }
  }
  vector<vector<bool>> cc_in(cc_cnt, vector<bool>(N));
  for (int i = 0; i < V2; i++){
    if (head[i]){
      for (int j = 0; j < N; j++){
        double f = px[i] * L[j].a + py[i] * L[j].b + L[j].c;
        cc_in[cc[i]][j] = f >= 0;
      }
    }
  }
  vector<double> area_sum(cc_cnt, 0);
  for (int i = 0; i < V2; i++){
    area_sum[cc[i]] += area[i];
  }
  double ans = 0;
  for (int i = 0; i < cc_cnt; i++){
    vector<bool> dp(V);
    for (int j = V - 1; j >= 0; j--){
      if (T[j][0] == 'L'){
        dp[j] = cc_in[i][stoi(T[j].substr(1))];
      }
      if (T[j] == "!"){
        dp[j] = !dp[c[j][0]];
      }
      if (T[j] == "&"){
        dp[j] = dp[c[j][0]] && dp[c[j][1]];
      }
      if (T[j] == "|"){
        dp[j] = dp[c[j][0]] || dp[c[j][1]];
      }
      if (T[j] == "^"){
        dp[j] = dp[c[j][0]] ^ dp[c[j][1]];
      }
    }
    if (dp[0]){
      ans += area_sum[i];
    }
  }
  cout << ans << endl;
}