#include <bits/stdc++.h>
#define LLI long long int
#define FOR(v, a, b) for(LLI v = (a); v < (b); ++v)
#define FORE(v, a, b) for(LLI v = (a); v <= (b); ++v)
#define REP(v, n) FOR(v, 0, n)
#define REPE(v, n) FORE(v, 0, n)
#define REV(v, a, b) for(LLI v = (a); v >= (b); --v)
#define ALL(x) (x).begin(), (x).end()
#define RALL(x) (x).rbegin(), (x).rend()
#define ITR(it, c) for(auto it = (c).begin(); it != (c).end(); ++it)
#define RITR(it, c) for(auto it = (c).rbegin(); it != (c).rend(); ++it)
#define EXIST(c,x) ((c).find(x) != (c).end())
#define fst first
#define snd second
#define popcount __builtin_popcount
#define UNIQ(v) v.erase(unique(ALL(v)), v.end())
#define bit(i) (1LL<<i)
#define sz(v) ((LLI)(v).size())

#ifdef DEBUG
#include <misc/C++/Debug.cpp>
#else
#define dump(...) ((void)0)
#endif

#define gcd __gcd

using namespace std;
template <class T> constexpr T lcm(T m, T n){return m/gcd(m,n)*n;}

template <typename I> void join(ostream &ost, I s, I t, string d=" "){for(auto i=s; i!=t; ++i){if(i!=s)ost<<d; ost<<*i;}ost<<endl;}
template <typename T> istream& operator>>(istream &is, vector<T> &v){for(auto &a : v) is >> a; return is;}
template <typename T, typename U> istream& operator>>(istream &is, pair<T,U> &p){is >> p.first >> p.second; return is;}

template <typename T, typename U> bool chmin(T &a, const U &b){return (a>b ? a=b, true : false);}
template <typename T, typename U> bool chmax(T &a, const U &b){return (a<b ? a=b, true : false);}
template <typename T, size_t N, typename U> void fill_array(T (&a)[N], const U &v){fill((U*)a, (U*)(a+N), v);}

double bin_search(double lb, double ub, const function<bool(double)> &f, bool tf=true){
  double mid;
 
  REP(i,200){
    mid = (lb+ub)/2;
 
    if(f(mid) ^ (!tf)){
      lb = mid;
    }else{
      ub = mid;
    }
  }
 
  return mid;
}


const double MIN = -1e10;
const double MAX = 1e10;

const double eps = 1e-9;


int main(){
  cin.tie(0);
  ios::sync_with_stdio(false);

  int N;
  while(cin >> N){
    vector<double> x(N), y(N);
    vector<char> d(N);

    REP(i,N){
      cin >> x[i] >> y[i] >> d[i];
    }
    
    auto funcx =
      [&](double t){
	double xmin = MAX, xmax = MIN;

	REP(i,N){
	  if(d[i] == 'R'){
	    chmin(xmin, x[i]+t);
	    chmax(xmax, x[i]+t);
	  }else if(d[i] == 'L'){
	    chmin(xmin, x[i]-t);
	    chmax(xmax, x[i]-t);
	  }else{
	    chmin(xmin, x[i]);
	    chmax(xmax, x[i]);
	  }
	}

	return xmax-xmin;
      };

    auto funcy =
      [&](double t){
	double ymin = MAX, ymax = MIN;

	REP(i,N){
	  if(d[i] == 'U'){
	    chmin(ymin, y[i]+t);
	    chmax(ymax, y[i]+t);
	  }else if(d[i] == 'D'){
	    chmin(ymin, y[i]-t);
	    chmax(ymax, y[i]-t);
	  }else{
	    chmin(ymin, y[i]);
	    chmax(ymax, y[i]);
	  }
	}

	return ymax-ymin;
      };

    auto check =
      [&](double t){
	double ret = funcx(t) * funcy(t);
	return ret;
      };

    auto x_diff =
      [&](double t){
	return (funcx(t+0.001)-funcx(t)) / 0.001;
      };

    auto y_diff =
      [&](double t){
	return (funcy(t+0.001)-funcy(t)) / 0.001;
      };

    
    vector<double> ts;
    
    ts.push_back(bin_search(0,MAX,[&](double t){return x_diff(t)>=-1-eps;}, false));    
    ts.push_back(bin_search(0,MAX,[&](double t){return x_diff(t)>=0-eps;}, false));    
    ts.push_back(bin_search(0,MAX,[&](double t){return x_diff(t)>=1-eps;}, false));    
    ts.push_back(bin_search(0,MAX,[&](double t){return x_diff(t)>=2-eps;}, false));    

    ts.push_back(bin_search(0,MAX,[&](double t){return y_diff(t)>=-1-eps;}, false));    
    ts.push_back(bin_search(0,MAX,[&](double t){return y_diff(t)>=0-eps;}, false));    
    ts.push_back(bin_search(0,MAX,[&](double t){return y_diff(t)>=1-eps;}, false));    
    ts.push_back(bin_search(0,MAX,[&](double t){return y_diff(t)>=2-eps;}, false));    
    

    double ans = min(check(0), check(MAX));

    REP(i,(int)ts.size()-1){
      double t = ts[i];

      t = round(t*2)/2;
      
      
      chmin(ans, check(t));
    }
    
    cout << fixed << setprecision(15) << ans << endl;
  }
  
  return 0;
}


Measured memory_bytes: 1920