#include <iostream>
#include <vector>
#include <map>
#include <unordered_map>
#include <queue>
#include <set>
#include <algorithm>
#include <string>
#include <math.h>
#include <limits.h>
#include <stack>
#include <complex>
#include <stdlib.h>
#include <stdio.h>
#include <functional>
#include <cfloat>
#include <math.h>


#define fs first
#define sc second

using namespace std;


typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<int, P> P2;


int main(){
    double x_max[3], y_max[3], x_min[3], y_min[3];
    bool u2 = false, d2 = false, l2 = false, r2 = false;
    int N;
    cin >> N;

    fill(x_max, x_max+3, -DBL_MAX);
    fill(y_max, y_max+3, -DBL_MAX);
    fill(x_min, x_min+3, DBL_MAX);
    fill(y_min, y_min+3, DBL_MAX);
    for(int i = 0; i < N; i++){
        double x, y;
        char d;
        cin >> x >> y >> d;
        int x_index, y_index;
        if(d == 'R'){
            r2 = true;
            x_index = 0, y_index = 2;
        }
        else if(d == 'L'){
            l2 = true;
            x_index = 1, y_index = 2;
        }
        else if(d == 'U'){
            u2 = true;
            x_index = 2, y_index = 0;
        }
        else{
            x_index = 2, y_index = 1;
            d2 = true;
        }
        x_max[x_index] = max(x_max[x_index], x);
        y_max[y_index] = max(y_max[y_index], y);
        x_min[x_index] = min(x_min[x_index], x);
        y_min[y_index] = min(y_min[y_index], y);
    }
    double xma = max(x_max[0], max(x_max[1], x_max[2]));
    double yma = max(y_max[0], max(y_max[1], y_max[2]));
    double xmi = min(x_min[0], min(x_min[1], x_min[2]));
    double ymi = min(y_min[0], min(y_min[1], y_min[2]));

    set<double> s;
    int c, r, h;
    bool cc, rr, hh;

    c = 0; r = 1; h = 2;
    cc = r2;
    rr = l2;
    hh = (u2 || d2);
    if(cc && rr) {
        double t = (x_max[r] - x_max[c]) / 2;
        if(t > 0) {
            s.insert(t);
        }
    }
    if(hh && cc){
        double t = (x_max[h] - x_max[c]);
        if(t > 0){
            s.insert(t);
        }
    }
    if(rr && hh){
        double t = (x_max[r] - x_max[h]);
        if(t > 0){
            s.insert(t);
        }
    }

    c = 1; r = 0; h = 2;
    cc = l2;
    rr = r2;
    hh = (u2 || d2);
    if(cc && rr) {
        double t = (-x_min[r] + x_min[c]) / 2;
        if(t > 0) {
            s.insert(t);
        }
    }
    if(hh && cc){
        double t = (-x_min[h] + x_min[c]);
        if(t > 0){
            s.insert(t);
        }
    }
    if(rr && hh){
        double t = (-x_min[r] + x_min[h]);
        if(t > 0){
            s.insert(t);
        }
    }

    c = 0; r = 1; h = 2;
    cc = u2;
    rr = d2;
    hh = (l2 || r2);
    if(cc && rr) {
        double t = (y_max[r] - y_max[c]) / 2;
        if(t > 0) {
            s.insert(t);
        }
    }
    if(hh && cc){
        double t = (y_max[h] - y_max[c]);
        if(t > 0){
            s.insert(t);
        }
    }
    if(rr && hh){
        double t = (y_max[r] - y_max[h]);
        if(t > 0){
            s.insert(t);
        }
    }

    c = 1; r = 0; h = 2;
    cc = d2;
    rr = u2;
    if(cc && rr) {
        double t = (-y_min[r] + y_min[c]) / 2;
        if(t > 0) {
            s.insert(t);
        }
    }
    if(hh && cc){
        double t = (-y_min[h] + y_min[c]);
        if(t > 0){
            s.insert(t);
        }
    }
    if(rr && hh){
        double t = (-y_min[r] + y_min[h]);
        if(t > 0){
            s.insert(t);
        }
    }

    double res = (xma - xmi) * (yma - ymi);
    for(auto t: s){
        xma = max(x_max[0] + t, max(x_max[1] - t, x_max[2]));
        xmi = min(x_min[0] + t, min(x_min[1] - t, x_min[2]));
        yma = max(y_max[0] + t, max(y_max[1] - t, y_max[2]));
        ymi = min(y_min[0] + t, min(y_min[1] - t, y_min[2]));
        res = min(res, (xma - xmi) * (yma - ymi));
    }
    printf("%.6f\n", res);



//    double xma, xmi, yma, ymi;
//    set<ll> s;
//    ll ty;
//    int c, r, h;
//    ty = 0;
//    c = 0;
//    r = 1;
//    h = 2;
//    if(x_max[c] >= x_max[r] && x_max[c] >= x_max[h]){
//        xma = x_max[c];
//    }
//    else if(x_max[r] > x_max[c] && x_max[r] > x_max[h]){
//        xma = x_max[r];
//        ll t1 = (x_max[r] - x_max[c]);
//        ll t2 = (x_max[r] - x_max[h]) * 2;
//        if(t1 > t2){
//            s.insert(t2);
//        }
//        s.insert(t1);
//    }
//    else{
//        xma = x_max[h];
//        ll t1 = (x_max[h] - x_max[r]) * 2;
//        s.insert(t1, ty);
//    }
//
//    ty = 1;
//    c = 1;
//    r = 0;
//    h = 2;
//    if(x_min[c] <= x_min[r] && x_min[c] <= x_min[h]){
//        xmi = x_min[c];
//    }
//    else if(x_min[r] < x_min[c] && x_min[r] < x_min[h]){
//        xmi = x_min[r];
//        ll t1 = x_min[r] - x_min[c];
//        ll t2 = (x_min[r] - x_min[h]) * 2;
//        if(t1 > t2){
//            s.insert(t2);
//        }
//        s.insert(t1);
//    }
//    else{
//        xmi = x_min[h];
//        ll t1 = (x_min[h] - x_min[r]) * 2;
//        s.insert(t1);
//    }
//
//    ty = 2;
//    c = 0;
//    r = 1;
//    h = 2;
//    if(y_max[c] >= y_max[r] && y_max[c] >= y_max[h]){
//        yma = y_max[c];
//    }
//    else if(y_max[r] > y_max[c] && y_max[r] > y_max[h]){
//        yma = y_max[r];
//        ll t1 = y_max[r] - y_max[c];
//        ll t2 = (y_max[r] - y_max[h]) * 2;
//        if(t1 > t2){
//            s.insert(t2);
//        }
//        s.insert(t1);
//    }
//    else{
//        yma = y_max[h];
//        ll t1 = (y_max[h] - y_max[r]) * 2;
//        s.insert(t1);
//    }
//
//    ty = 3;
//    c = 1;
//    r = 0;
//    h = 2;
//    if(y_min[c] <= y_min[r] && y_min[c] <= y_min[h]){
//        ymi = y_min[c];
//    }
//    else if(y_min[r] < y_min[c] && y_min[r] < y_min[h]){
//        ymi = y_min[r];
//        ll t1 = y_min[r] - y_min[c];
//        ll t2 = (y_min[r] - y_min[h]) * 2;
//        if(t1 > t2){
//            s.insert(t2);
//        }
//        s.insert(t1);
//    }
//    else{
//        ymi = y_min[h];
//        ll t1 = (y_min[h] - y_min[r]) * 2;
//        s.insert(t1);
//    }
//
//    double res = (xma - xmi) * (yma - ymi);
//    for(auto ss: s){
//        double t1 = (double)ss;
//        if(t1 < 0){
//            continue;
//        }
//        xma = max(x_max[0] + t1, max(x_max[1] - t1, x_max[2]));
//        xmi = min(x_min[1] - t1, min(x_min[1] + t1, x_min[2]));
//        yma = max(y_max[0] + t1, max(y_max[1] - t1, y_max[2]));
//        ymi = min(y_min[1] - t1, min(y_min[1] + t1, y_min[2]));
//
//        res = min((xma - xmi) * (yma - ymi), res);
//    }
//    cout << res << endl;




    return 0;
}


Measured memory_bytes: 384