#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector,fast-math")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//#pragma comment(linker, "/stack:200000000")

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef double ld;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef pair<ld,ld> pdd;

#define X first
#define Y second

//#include <boost/unordered_map.hpp>
//using namespace boost;

/*
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> rbtree;
rbtree T;
*/

namespace io{
	const int L = (1 << 20) + 1;

	char buf[L], *S , *T, c;

	char getchar() {
		if(__builtin_expect(S == T, 0)) {
			T = (S = buf) + fread(buf, 1, L, stdin);
			return (S == T ? EOF : *S++);
		}
		return *S++;
	}

	int inp() {
		int x = 0, f = 1; char ch;
		for(ch = getchar(); !isdigit(ch); ch = getchar())
			if(ch == '-') f = -1;
		for(; isdigit(ch); x = x * 10 + ch - '0', ch = getchar());
		return x * f;
	}

	unsigned inpu()
	{
		unsigned x = 0; char ch;
		for(ch = getchar(); !isdigit(ch); ch = getchar());
		for(; isdigit(ch); x = x * 10 + ch - '0', ch = getchar());
		return x;
	}

	ll inp_ll() {
		ll x = 0; int f = 1; char ch;
		for(ch = getchar(); !isdigit(ch); ch = getchar())
			if(ch == '-') f = -1;
		for(; isdigit(ch); x = x * 10 + ch - '0', ch = getchar());
		return x * f;
	}

	char B[45], *outs=B+40, *outr=B+40;
	template<class T>
	inline void print(register T a,register char x=0){
		if(x) *--outs = x, x = 0;

		if(!a)*--outs = '0';
		else
			while(a)
				*--outs = (a % 10) + 48, a /= 10;

		if(x)
			*--outs = x;

		fwrite(outs, outr - outs , 1, stdout);
		outs = outr;
	}
};

using io :: print;
using io :: inp;
using io :: inpu;
using io :: inp_ll;

using i32 = int;
using i64 = long long;
using u8 = unsigned char;
using u32 = unsigned;
using u64 = unsigned long long;
using f64 = double;
using f80 = long double;
//using i128 = __int128_t;
//using u128 = __uint128_t;
using i128 = i64;
using u128 = u64;

ll power(ll a, ll b, ll p)
{
	if (!b) return 1;
	ll t = power(a, b/2, p);
	t = t*t%p;
	if (b&1) t = t*a%p;
	return t;
}

ll exgcd(ll a, ll b, ll &x, ll &y)
{
	if (b == 0)
	{
		x = 1;
		y = 0;
		return a;
	}
	ll px, py;
	ll d = exgcd(b, a%b, px, py);
	x = py;
	y = px-a/b*py;
	return d;
}

template<class T>
inline void freshmin(T &a, const T &b)
{
	if (a > b) a = b;
}

template<class T>
inline void freshmax(T &a, const T &b)
{
	if (a < b) a = b;
}

const int MOD = 1000000007;
const int INF = 1000000000;
const int MAXN = 100010;
const int MAXK = 20;

int n;
int x[MAXN], y[MAXN];
vector<ll> ax, bx, cx, ay, by, cy;

int get(ll &minn, ll &maxn, vector<ll> &v)
{
	if (v.empty())
		minn = INF, maxn = -INF;
	else
		minn = v.front(), maxn = v.back();
}

ll minax, maxax, minbx, maxbx, mincx, maxcx;
ll minay, maxay, minby, maxby, mincy, maxcy;

ll ans = 8000000000000000000LL;

void check(ll t)
{
	ll minx = INF;
	if (minax <= maxax) freshmin(minx, minax+t);
	if (minbx <= maxbx) freshmin(minx, minbx-t);
	if (mincx <= maxcx) freshmin(minx, mincx);
	
	ll maxx = -INF;
	if (minax <= maxax) freshmax(maxx, maxax+t);
	if (minbx <= maxbx) freshmax(maxx, maxbx-t);
	if (mincx <= maxcx) freshmax(maxx, maxcx);
	
	ll miny = INF;
	if (minay <= maxay) freshmin(miny, minay+t);
	if (minby <= maxby) freshmin(miny, minby-t);
	if (mincy <= maxcy) freshmin(miny, mincy);
	
	ll maxy = -INF;
	if (minay <= maxay) freshmax(maxy, maxay+t);
	if (minby <= maxby) freshmax(maxy, maxby-t);
	if (mincy <= maxcy) freshmax(maxy, maxcy);
	
	ll ret = (maxx-minx)*(maxy-miny);
	//printf("%lld %lld\n", t, ret);
	ans = min(ans, ret);
}

void solve(ll minax, ll maxax, ll minbx, ll maxbx, ll mincx, ll maxcx)
{
	//minax+t, maxax+t, minbx-t, maxbx-t, mincx, maxcx
	
	if (minax <= maxax && minbx <= maxbx)
	{
		check((minbx-minax)/2);
		check((maxbx-minax)/2);
		check((minbx-maxax)/2);
		check((maxbx-maxax)/2);
	}
	
	if (minax <= maxax && mincx <= maxcx)
	{
		check(mincx-minax);
		check(maxcx-minax);
		check(mincx-maxax);
		check(maxcx-maxax);
	}
	
	if (minbx <= maxbx && mincx <= maxcx)
	{
		check(minbx-mincx);
		check(maxbx-mincx);
		check(minbx-maxcx);
		check(maxbx-maxcx);
	}
}

int main()
{
	
	scanf("%d", &n);
	for (int i = 1; i <= n; ++ i)
	{
		int x, y;
		char d;
		scanf("%d%d %c", &x, &y, &d);
		::x[i] = x;
		::y[i] = y;
		x *= 2;
		y *= 2;
		if (d == 'R')
		{
			ax.push_back(x);
			cy.push_back(y);
		}
		else if (d == 'L')
		{
			bx.push_back(x);
			cy.push_back(y);
		}
		else if (d == 'U')
		{
			cx.push_back(x);
			ay.push_back(y);
		}
		else if (d == 'D')
		{
			cx.push_back(x);
			by.push_back(y);
		}
	}
	sort(ax.begin(), ax.end());
	sort(bx.begin(), bx.end());
	sort(cx.begin(), cx.end());
	sort(ay.begin(), ay.end());
	sort(by.begin(), by.end());
	sort(cy.begin(), cy.end());
	/*
	ax+t, ay+t
	bx-t, by-t
	cx, cy
	*/
	
	get(minax, maxax, ax);
	get(minbx, maxbx, bx);
	get(mincx, maxcx, cx);
	get(minay, maxay, ay);
	get(minby, maxby, by);
	get(mincy, maxcy, cy);
	
	for (int t = 0; t <= 400000000; ++ t)
		check(t);
	
	/*
	solve(minax, maxax, minbx, maxbx, mincx, maxcx);
	solve(minay, maxay, minby, maxby, mincy, maxcy);
	*/
	printf("%lld.%02lld\n", ans/4, ans%4*25);
	
	return 0;
}


Measured memory_bytes: 3056