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: INF = float("inf")
  
  N = int(input())
  
  xConstMin, xConstMax = INF, -INF
  xAscMin, xAscMax = INF, -INF
  xDescMin, xDescMax = INF, -INF
  yConstMin, yConstMax = INF, -INF
  yAscMin, yAscMax = INF, -INF
  yDescMin, yDescMax = INF, -INF
  for _ in range(N):
      x, y, d = input().split()
      x, y = int(x), int(y)
      if d == "R":
          xAscMax = max(xAscMax, x)
          xAscMin = min(xAscMin, x)
          yConstMax = max(yConstMax, y)
          yConstMin = min(yConstMin, y)
      elif d == "L":
          xDescMax = max(xDescMax, x)
          xDescMin = min(xDescMin, x)
          yConstMax = max(yConstMax, y)
          yConstMin = min(yConstMin, y)
      elif d == "U":
          xConstMax = max(xConstMax, x)
          xConstMin = min(xConstMin, x)
          yAscMax = max(yAscMax, y)
          yAscMin = min(yAscMin, y)
      elif d == "D":
          xConstMax = max(xConstMax, x)
          xConstMin = min(xConstMin, x)
          yDescMax = max(yDescMax, y)
          yDescMin = min(yDescMin, y)
  
  tms = []
  
  t1 = max(0, xDescMax - xConstMax)
  t2 = max(0, xConstMax - xAscMax)
  if t1 >= t2:
      t = max(0, (xDescMax - xAscMax) / 2)
      tms.append(t)
  else:
      tms.append(t1)
      tms.append(t2)
  
  t1 = max(0, xConstMin - xAscMin)
  t2 = max(0, xDescMin - xConstMin)
  if t1 >= t2:
      t = max(0, (xDescMin - xAscMin) / 2)
      tms.append(t)
  else:
      tms.append(t1)
      tms.append(t2)
  
  t1 = max(0, yDescMax - yConstMax)
  t2 = max(0, yConstMax - yAscMax)
  if t1 >= t2:
      t = max(0, (yDescMax - yAscMax) / 2)
      tms.append(t)
  else:
      tms.append(t1)
      tms.append(t2)
  
  t1 = max(0, yConstMin - yAscMin)
  t2 = max(0, yDescMin - yConstMin)
  if t1 >= t2:
      t = max(0, (yDescMin - yAscMin) / 2)
      tms.append(t)
  else:
      tms.append(t1)
      tms.append(t2)
  
  ans = INF
  for tm in tms:
      if tm == INF:
          continue
  
      xs = [
          xConstMin,
          xConstMax,
          xAscMin + tm,
          xAscMax + tm,
          xDescMin - tm,
          xDescMax - tm,
      ]
      ys = [
          yConstMin,
          yConstMax,
          yAscMin + tm,
          yAscMax + tm,
          yDescMin - tm,
          yDescMax - tm,
      ]
  
      xMin, xMax = INF, -INF
      for x in xs:
          if x == INF or x == -INF:
              continue
          xMin = min(xMin, x)
          xMax = max(xMax, x)
  
      yMin, yMax = INF, -INF
      for y in ys:
          if y == INF or y == -INF:
              continue
          yMin = min(yMin, y)
          yMax = max(yMax, y)
  
      ans = min(ans, (xMax - xMin) * (yMax - yMin))
  
  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"}]