import std.stdio, std.array, std.string, std.conv, std.algorithm;
import std.typecons, std.range, std.random, std.math, std.container;
import std.numeric, std.bigint, core.bitop, std.bitmanip;

alias Point = Tuple!(long, "x", long, "y", char, "d");

void main() {
    auto N = readln.chomp.to!int;
    auto P = new Point[](N);
    Point[] L, R, D, U;
    foreach (i; 0..N) {
        auto s = readln.split;
        long x = s[0].to!long * 2;
        long y = s[1].to!long * 2;
        char d = s[2].front.to!char;
        auto p = Point(x, y, d);
        P[i] = p;
        if (d == 'L') L ~= p;
        else if (d == 'R') R ~= p;
        else if (d == 'D') D ~= p;
        else U ~= p;
    }

    long ans = 1L << 59;
    long[] times = [0];

    if (!L.empty) {
        long xmin = P.filter!(a => a[2] != 'L' && a[2] != 'R').map!(a => a[0]).reduce!min;
        long Lxmin = L.map!(a => a[0]).reduce!min;
        if (xmin < Lxmin) times ~= (Lxmin - xmin);
        long xmax = P.filter!(a => a[2] != 'L' && a[2] != 'R').map!(a => a[0]).reduce!max;
        long Lxmax = L.map!(a => a[0]).reduce!max;
        if (xmax < Lxmax) times ~= (Lxmax - xmax);
    }

    if (!R.empty) {
        long xmax = P.filter!(a => a[2] != 'R' && a[2] != 'L').map!(a => a[0]).reduce!max;
        long Rxmax = R.map!(a => a[0]).reduce!max;
        if (xmax > Rxmax) times ~= (xmax - Rxmax);
        long xmin = P.filter!(a => a[2] != 'R' && a[2] != 'L').map!(a => a[0]).reduce!min;
        long Rxmin = R.map!(a => a[0]).reduce!min;
        if (xmin > Rxmin) times ~= (xmin - Rxmin);
    }

    if (!D.empty) {
        long ymin = P.filter!(a => a[2] != 'D' && a[2] != 'U').map!(a => a[1]).reduce!min;
        long Dymin = D.map!(a => a[1]).reduce!min;
        if (ymin < Dymin) times ~= (Dymin - ymin);
        long ymax = P.filter!(a => a[2] != 'D' && a[2] != 'U').map!(a => a[1]).reduce!max;
        long Dymax = D.map!(a => a[1]).reduce!max;
        if (ymax < Dymax) times ~= (Dymax - ymax);
    }

    if (!U.empty) {
        long ymin = P.filter!(a => a[2] != 'U' && a[2] != 'D').map!(a => a[1]).reduce!min;
        long Uymin = U.map!(a => a[1]).reduce!min;
        if (ymin > Uymin) times ~= (ymin - Uymin);
        long ymax = P.filter!(a => a[2] != 'U' && a[2] != 'D').map!(a => a[1]).reduce!max;
        long Uymax = U.map!(a => a[1]).reduce!max;
        if (ymax > Uymax) times ~= (ymax - Uymax);
    }


    if (!L.empty && !R.empty){
        long Lxmax = L.map!(a => a[0]).reduce!max;
        long Rxmax = R.map!(a => a[0]).reduce!max;
        long Lxmin = L.map!(a => a[0]).reduce!min;
        long Rxmin = R.map!(a => a[0]).reduce!min;
        if (Lxmax > Rxmax) times ~= (Lxmax - Rxmax) / 2;
        if (Lxmin > Rxmin) times ~= (Lxmin - Rxmin) / 2;
    }

    if (!U.empty && !D.empty) {
        long Dymax = D.map!(a => a[1]).reduce!max;
        long Uymax = U.map!(a => a[1]).reduce!max;
        long Dymin = D.map!(a => a[1]).reduce!min;
        long Uymin = U.map!(a => a[1]).reduce!min;
        if (Dymax > Uymax) times ~= (Dymax - Uymax) / 2;
        if (Dymin > Uymin) times ~= (Dymin - Uymin) / 2;
    }

    foreach (t; times) {
        auto A = P.dup;
        foreach (i; 0..N) {
            if (A[i][2] == 'L') A[i][0] -= t;
            else if (A[i][2] == 'R') A[i][0] += t;
            else if (A[i][2] == 'D') A[i][1] -= t;
            else A[i][1] += t;
        }
        long xmax = A.map!(a => a[0]).reduce!max;
        long xmin = A.map!(a => a[0]).reduce!min;
        long ymax = A.map!(a => a[1]).reduce!max;
        long ymin = A.map!(a => a[1]).reduce!min;
        ans = min(ans, (xmax - xmin) * (ymax - ymin));
    }

    writefln("%.5f", 1.0L * ans / 4);

}
