output_description: Print the minimum possible value of (x_{max} - x_{min}) \times (y_{max} -
  y_{min}).
  
  The output will be considered correct when its absolute or relative error from
  the judge's output is at most 10^{-9}.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      x_1 y_1 d_1
      x_2 y_2 d_2
      .
      .
      .
      x_N y_N d_N
attempt: N = int(input())
  xyd = [list(input().split()) for _ in range(N)]
  
  
  def nasu(s, e, f, n, inf):
      L = [0] * 3
      a, b, c = inf, inf, inf
      for i in range(N):
          t = int(xyd[i][n])
          if xyd[i][2] == s:
              a = f(a, t)
          elif xyd[i][2] == e:
              b = f(b, t)
          else:
              c = f(c, t)
      L[0] = a
      if f(a, c) == a:
          L[1] = abs(a - c)
      else:
          L[0], L[1] = c, 0
      if f(L[0], b) != b:
          if f(c, b) == c:
              L[2] = abs(b - c)
              if L[1] > L[2]:
                  L[2] = abs(a - b) / 2
                  L[1] = L[2]
          else:
              L[2] = abs(a - b) / 2
              L[1] = L[2]
      else:
          L = [b, 0, 0]
      for i in range(3):
          if abs(L[i]) > abs(inf) / 2:
              L[i] = abs(inf)
      return L
  
  
  inf = 10**10
  R = nasu("L", "R", max, 0, -inf)
  L = nasu("R", "L", min, 0, inf)
  U = nasu("D", "U", max, 1, -inf)
  D = nasu("U", "D", min, 1, inf)
  
  
  def honya(x):
      r = honyaraka(R, x, 1)
      l = honyaraka(L, x, -1)
      u = honyaraka(U, x, 1)
      d = honyaraka(D, x, -1)
      return abs(r - l) * abs(u - d)
  
  
  def honyaraka(X, x, f):
      a, b, c = X
      if x <= b:
          return a + x * f * -1
      if x < c:
          return a + b * f * -1
      return a + b * f * -1 + (x - c) * f
  
  
  ans = honya(0)
  T = [R, L, U, D]
  for i in range(4):
      for j in range(1, 3):
          x = T[i][j]
          if x != inf:
              ans = min(ans, honya(x))
  
  print(ans)
  
problem_description: Statement
  
  There are N points in a two-dimensional plane. The initial coordinates of the
  i-th point are (x_i, y_i). Now, each point starts moving at a speed of 1 per
  second, in a direction parallel to the x\- or y\- axis. You are given a
  character d_i that represents the specific direction in which the i-th point
  moves, as follows:
  
    * If d_i = `R`, the i-th point moves in the positive x direction;
    * If d_i = `L`, the i-th point moves in the negative x direction;
    * If d_i = `U`, the i-th point moves in the positive y direction;
    * If d_i = `D`, the i-th point moves in the negative y direction.
  
  You can stop all the points at some moment of your choice after they start
  moving (including the moment they start moving). Then, let x_{max} and x_{min}
  be the maximum and minimum among the x-coordinates of the N points,
  respectively. Similarly, let y_{max} and y_{min} be the maximum and minimum
  among the y-coordinates of the N points, respectively.
  
  Find the minimum possible value of (x_{max} - x_{min}) \times (y_{max} -
  y_{min}) and print it.
samples: [{"input": "2\n    0 3 D\n    3 0 L", "output": "0\n    \n\nAfter three seconds, the two points will meet at the origin. The value in\nquestion will be 0 at that moment.\n\n* * *"}, {"input": "5\n    -7 -10 U\n    7 -6 U\n    -8 7 D\n    -3 3 D\n    0 -6 R", "output": "97.5\n    \n\nThe answer may not be an integer.\n\n* * *"}, {"input": "20\n    6 -10 R\n    -4 -9 U\n    9 6 D\n    -3 -2 R\n    0 7 D\n    4 5 D\n    10 -10 U\n    -1 -8 U\n    10 -6 D\n    8 -5 U\n    6 4 D\n    0 3 D\n    7 9 R\n    9 -4 R\n    3 10 D\n    1 9 U\n    1 -6 U\n    9 -8 R\n    6 7 D\n    7 -3 D", "output": "273"}]