#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
using ll = long long;
using u64 = uint_fast64_t;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
#define rep(i, n) for(int i = 0; i < (n); ++i)
#define all(x) (x).begin(),(x).end()
constexpr char ln =  '\n';
constexpr long long MOD = 1000000007;
//constexpr long long MOD = 998244353;
template<class T1, class T2> inline bool chmax(T1 &a, T2 b) { if (a < b) { a = b; return true;} return false; }
template<class T1, class T2> inline bool chmin(T1 &a, T2 b) { if (a > b) { a = b; return true;} return false; }
inline int popcount(int x) {return __builtin_popcount(x);}
inline int popcount(long long x) {return __builtin_popcountll(x);}
void print() { cout << "\n"; }
template<class T, class... Args>
void print(const T &x, const Args &... args) {
    cout << x << " ";
    print(args...);
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////

int main() {
    ios::sync_with_stdio(false); cin.tie(nullptr);
    int N; cin >> N;
    // 0:動かない 1:正 2:負
    vector<ll> MAXX(3),MAXY(3),MINX(3),MINY(3);
    rep(i,3) {
        MAXX[i] = MAXY[i] = -1e9;
        MINX[i] = MINY[i] = 1e9;
    }
    rep(i,N) {
        int x,y;
        char d;
        cin >> x >> y >> d;
        if (d=='R') {
            chmax(MAXX[1],x*2);
            chmin(MINX[1],x*2);
            chmax(MAXY[0],y*2);
            chmin(MINY[0],y*2);
        }
        if (d=='L') {
            chmax(MAXX[2],x*2);
            chmin(MINX[2],x*2);
            chmax(MAXY[0],y*2);
            chmin(MINY[0],y*2);
        }
        if (d=='U') {
            chmax(MAXY[1],y*2);
            chmin(MINY[1],y*2);
            chmax(MAXX[0],x*2);
            chmin(MINX[0],x*2);
        }
        if (d=='D') {
            chmax(MAXY[2],y*2);
            chmin(MINY[2],y*2);
            chmax(MAXX[0],x*2);
            chmin(MINX[0],x*2);
        }
    }

    auto func=[](ll p1, int v1, ll p2, int v2)->ll {
        if (abs(p1)==1e9 or abs(p2) == 1e9) return -1;
        if (v1==0 and v2==1) {
            if (p2 > p1) return -1;
            return p1-p2;
        }
        if (v1==0 and v2==2) {
            if (p1 > p2) return -1;
            return p2-p1;
        }
        if (v1==1 and v2==2) {
            if (p1 > p2) return -1;
            return (p2-p1)/2;
        }
    };
    vector<ll> T = {0};
    rep(i,2) {
        for (int j = i+1; j < 3; j++) {
            if (func(MAXX[i],i,MAXX[j],j)!=-1) T.emplace_back(func(MAXX[i],i,MAXX[j],j));
            if (func(MAXX[i],i,MINX[j],j)!=-1) T.emplace_back(func(MAXX[i],i,MINX[j],j));
            if (func(MINX[i],i,MAXX[j],j)!=-1) T.emplace_back(func(MINX[i],i,MAXX[j],j));
            if (func(MINX[i],i,MINX[j],j)!=-1) T.emplace_back(func(MINX[i],i,MINX[j],j));
            if (func(MAXY[i],i,MAXY[j],j)!=-1) T.emplace_back(func(MAXY[i],i,MAXY[j],j));
            if (func(MAXY[i],i,MINY[j],j)!=-1) T.emplace_back(func(MAXY[i],i,MINY[j],j));
            if (func(MINY[i],i,MAXY[j],j)!=-1) T.emplace_back(func(MINY[i],i,MAXY[j],j));
            if (func(MINY[i],i,MINY[j],j)!=-1) T.emplace_back(func(MINY[i],i,MINY[j],j));
        }
    }

    sort(all(T));
    T.erase(unique(begin(T), end(T)), end(T));

    ll ans = 5e18;
    for (auto t : T) {
        ll maxx = -1e9, minx = 1e9, maxy = -1e9, miny = 1e9;
        rep(i,3) {
            if (abs(MAXX[i]) != 1e9 and abs(MINX[i]) != 1e9) {
                if (i==0) {
                    chmax(maxx,MAXX[i]);
                    chmin(minx,MAXX[i]);
                    chmax(maxx,MINX[i]);
                    chmin(minx,MINX[i]);
                }
                if (i==1) {
                    chmax(maxx,MAXX[i]+t);
                    chmin(minx,MAXX[i]+t);
                    chmax(maxx,MINX[i]+t);
                    chmin(minx,MINX[i]+t);
                }
                if (i==2) {
                    chmax(maxx,MAXX[i]-t);
                    chmin(minx,MAXX[i]-t);
                    chmax(maxx,MINX[i]-t);
                    chmin(minx,MINX[i]-t);
                }
            }
            if (abs(MAXY[i]) != 1e9 and abs(MINY[i]) != 1e9) {
                if (i==0) {
                    chmax(maxy,MAXY[i]);
                    chmin(miny,MAXY[i]);
                    chmax(maxy,MINY[i]);
                    chmin(miny,MINY[i]);
                }
                if (i==1) {
                    chmax(maxy,MAXY[i]+t);
                    chmin(miny,MAXY[i]+t);
                    chmax(maxy,MINY[i]+t);
                    chmin(miny,MINY[i]+t);
                }
                if (i==2) {
                    chmax(maxy,MAXY[i]-t);
                    chmin(miny,MAXY[i]-t);
                    chmax(maxy,MINY[i]-t);
                    chmin(miny,MINY[i]-t);
                }
            }
        }

        chmin(ans,(maxx-minx)*(maxy-miny));
    }

    cout << fixed << setprecision(5) << double(ans)/4 << ln;
}

Measured memory_bytes: 256