#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <chrono>
#define _USE_MATH_DEFINES
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;

#define FOR(i,m,n) for(int i=(m);i<(n);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) (v).begin(),(v).end()

const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const double EPS = 1e-8;
const int MOD = 1000000007; // 998244353;
const int dy[] = {1, 0, -1, 0}, dx[] = {0, -1, 0, 1};
/*-------------------------------------------------*/
int main() {
  // freopen("input.txt", "r", stdin);

  chrono::system_clock::time_point begin, end;
  begin = chrono::system_clock::now();
  int n; cin >> n;
  vector<int> x(n), y(n); vector<char> dir(n);
  map<char, int> mp; mp['R'] = 0; mp['L'] = 1; mp['U'] = 2; mp['D'] = 3;
  vector<vector<int> > memo(4, vector<int>(4));
  REP(i, 4) {
    memo[i][0] = INF; // x_min
    memo[i][1] = -INF; // x_max
    memo[i][2] = INF; // y_min
    memo[i][3] = -INF; // y_max
  }
  REP(i, n) {
    cin >> x[i] >> y[i] >> dir[i];
    memo[mp[dir[i]]][0] = min(memo[mp[dir[i]]][0], x[i]);
    memo[mp[dir[i]]][1] = max(memo[mp[dir[i]]][1], x[i]);
    memo[mp[dir[i]]][2] = min(memo[mp[dir[i]]][2], y[i]);
    memo[mp[dir[i]]][3] = max(memo[mp[dir[i]]][3], y[i]);
  }
  double r = max(memo[2][1], memo[3][1]);
  double l = min(memo[2][0], memo[3][0]);
  double u = max(memo[0][3], memo[1][3]);
  double d = min(memo[0][2], memo[1][2]);
  double left = 0, right = 1e18;
  REP(i, 10000) {
    double tm = (left * 2 + right) / 3;
    double rr = max({r, memo[1][1] - tm, memo[0][1] + tm});
    double ll = min({l, memo[0][0] + tm, memo[1][0] - tm});
    double uu = max({u, memo[3][3] - tm, memo[2][3] + tm});
    double dd = min({d, memo[2][2] + tm, memo[3][2] - tm});
    double hidari = (rr - ll) * (uu - dd);
    double tm2 = (left + right * 2) / 3;
    rr = max({r, memo[1][1] - tm2, memo[0][1] + tm2});
    ll = min({l, memo[0][0] + tm2, memo[1][0] - tm2});
    uu = max({u, memo[3][3] - tm2, memo[2][3] + tm2});
    dd = min({d, memo[2][2] + tm2, memo[3][2] - tm2});
    double migi = (rr - ll) * (uu - dd);
    if (hidari > migi) left = tm;
    else right = tm2;
  }
  double tm = (left + right) * 0.5;
  double rr = max({r, memo[1][1] - tm, memo[0][1] + tm});
  double ll = min({l, memo[0][0] + tm, memo[1][0] - tm});
  double uu = max({u, memo[3][3] - tm, memo[2][3] + tm});
  double dd = min({d, memo[2][2] + tm, memo[3][2] - tm});
  double ans = (rr - ll) * (uu - dd);
  // double ans = LINF;
  // REP(i, 5) {
  //   double tm = 0;
  //   if (i == 0) {
  //     if (memo[3][3] == -INF && memo[2][3] == -INF) continue;
  //     if (memo[3][3] == -INF) {
  //       tm = u - memo[2][3];
  //     } else if (memo[2][3] == -INF) {
  //       tm = memo[3][3] - d;
  //     } else {
  //       tm = (memo[3][3] - memo[2][3]) * 0.5;
  //     }
  //   } else if (i == 1) {
  //     if (memo[3][2] == INF && memo[2][2] == INF) continue;
  //     if (memo[3][2] == INF) {
  //       tm = u - memo[2][2];
  //     } else if (memo[2][2] == INF) {
  //       tm = memo[3][2] - d;
  //     } else {
  //       tm = (memo[3][2] - memo[2][2]) * 0.5;
  //     }
  //   } else if (i == 2) {
  //     if (memo[1][1] == -INF && memo[0][1] == -INF) continue;
  //     if (memo[1][1] == -INF) {
  //       tm = r - memo[0][1];
  //     } else if (memo[0][1] == -INF) {
  //       tm = memo[1][1] - l;
  //     } else {
  //       tm = (memo[1][1] - memo[0][1]) * 0.5;
  //     }
  //   } else if (i == 3) {
  //     if (memo[1][0] == INF && memo[0][0] == INF) continue;
  //     if (memo[1][0] == INF) {
  //       tm = r - memo[0][0];
  //     } else if (memo[0][0] == INF) {
  //       tm = memo[1][0] - l;
  //     } else {
  //       tm = (memo[1][0] - memo[0][0]) * 0.5;
  //     }
  //   }
  //   if (tm < 0) continue;
  //   double rr = max({r, memo[1][1] - tm, memo[0][1] + tm});
  //   double ll = min({l, memo[0][0] + tm, memo[1][0] - tm});
  //   double uu = max({u, memo[3][3] - tm, memo[2][3] + tm});
  //   double dd = min({d, memo[2][2] + tm, memo[3][2] - tm});
  //   ans = min(ans, (rr - ll) * (uu - dd));
  // }
  // end = chrono::system_clock::now();
  // long double elapsed = chrono::duration_cast<chrono::milliseconds>(end - begin).count();
  // double tm = 0.5;
  // while (elapsed <= 4990) {
  //   tm += 0.5;
  //   double rr = max({r, memo[1][1] - tm, memo[0][1] + tm});
  //   double ll = min({l, memo[0][0] + tm, memo[1][0] - tm});
  //   double uu = max({u, memo[3][3] - tm, memo[2][3] + tm});
  //   double dd = min({d, memo[2][2] + tm, memo[3][2] - tm});
  //   ans = min(ans, (rr - ll) * (uu - dd));
  //   end = chrono::system_clock::now();
  //   elapsed = chrono::duration_cast<chrono::milliseconds>(end - begin).count();
  // }
  printf("%.10f\n", ans);
  return 0;
}


Measured memory_bytes: 1152