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())
  M = {"R": [], "L": [], "U": [], "D": [], "X": [], "Y": []}
  for _ in range(N):
      x, y, d = input().split()
      if d in ["R", "L"]:
          M[d].append(int(x))
          M["Y"].append(int(y))
      else:
          M["X"].append(int(x))
          M[d].append(int(y))
  for d in "RLDUXY":
      M[d] = sorted(M[d])
  T = [0] * 13
  T[0] = M["X"][0] - M["R"][0] if M["X"] and M["R"] else -1
  T[1] = M["L"][0] - M["X"][0] if M["X"] and M["L"] else -1
  T[2] = (M["L"][0] - M["R"][0]) / 2 if M["L"] and M["R"] else -1
  T[3] = M["X"][-1] - M["R"][-1] if M["X"] and M["R"] else -1
  T[4] = M["L"][-1] - M["X"][-1] if M["X"] and M["L"] else -1
  T[5] = (M["L"][-1] - M["R"][-1]) / 2 if M["L"] and M["R"] else -1
  T[6] = M["Y"][-1] - M["U"][-1] if M["Y"] and M["U"] else -1
  T[7] = M["D"][-1] - M["Y"][-1] if M["Y"] and M["D"] else -1
  T[8] = (M["D"][-1] - M["U"][-1]) / 2 if M["D"] and M["U"] else -1
  T[9] = M["Y"][0] - M["U"][0] if M["Y"] and M["U"] else -1
  T[10] = M["D"][0] - M["Y"][0] if M["Y"] and M["D"] else -1
  T[11] = (M["D"][0] - M["U"][0]) / 2 if M["D"] and M["U"] else -1
  Rect = [-1] * 13
  for i, t in enumerate(T):
      if t < 0:
          continue
      R = []
      L = []
      U = []
      D = []
      if M["R"]:
          R.append(M["R"][-1] + t)
          L.append(M["R"][0] + t)
      if M["L"]:
          R.append(M["L"][-1] - t)
          L.append(M["L"][0] - t)
      if M["U"]:
          U.append(M["U"][-1] + t)
          D.append(M["U"][0] + t)
      if M["D"]:
          U.append(M["D"][-1] - t)
          D.append(M["D"][0] - t)
      if M["X"]:
          R.append(M["X"][-1])
          L.append(M["X"][0])
      if M["Y"]:
          U.append(M["Y"][-1])
          D.append(M["Y"][0])
      Rect[i] = (max(R) - min(L)) * (max(U) - min(D))
  print(min([r for r in Rect if r >= 0]))
  
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"}]