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: I = float("inf")
  N = int(input())
  XYD = [input().split() for _ in range(N)]
  xL = set()
  xR = set()
  xS = set()
  yD = set()
  yU = set()
  yS = set()
  for xyd in XYD:
      x, y, d = xyd
      x = int(x)
      y = int(y)
      if d == "L":
          xL.add(x)
          yS.add(y)
      elif d == "R":
          xR.add(x)
          yS.add(y)
      elif d == "U":
          yU.add(y)
          xS.add(x)
      else:
          yD.add(y)
          xS.add(x)
  # xmin
  xRmin = min(xR | {I})
  xLmin = min(xL | {I})
  xSmin = min(xS | {I})
  # xmax
  xRmax = max(xR | {-I})
  xLmax = max(xL | {-I})
  xSmax = max(xS | {-I})
  
  x2m = xLmax - xRmin
  x1m = max(xSmax - xRmin, xLmax - xSmin)
  x0 = max(xRmax - xRmin, xLmax - xLmin, xSmax - xSmin)
  x1 = max(xSmax - xLmin, xRmax - xSmin)
  x2 = xRmax - xLmin
  # ymin
  yUmin = min(yU | {I})
  yDmin = min(yD | {I})
  ySmin = min(yS | {I})
  # ymax
  yUmax = max(yU | {-I})
  yDmax = max(yD | {-I})
  ySmax = max(yS | {-I})
  
  y2m = yDmax - yUmin
  y1m = max(ySmax - yUmin, yDmax - ySmin)
  y0 = max(yUmax - yUmin, yDmax - yDmin, ySmax - ySmin)
  y1 = max(ySmax - yDmin, yUmax - ySmin)
  y2 = yUmax - yDmin
  
  print(x2m, x1m, x0, x1, x2)
  print(y2m, y1m, y0, y1, y2)
  
  
  def dd(t):
      if 0 <= t < I:
          return max(x2m - 2 * t, x1m - t, x0, x1 + t, x2 + 2 * t) * max(
              y2m - 2 * t, y1m - t, y0, y1 + t, y2 + 2 * t
          )
      else:
          return I
  
  
  t = [0, x2m / 2, x1m, y2m / 2, y1m]
  t += [x2m - x1m, x1m - x0, x0 - x1, x1 - x2]
  t += [(x2m - x0) / 2, (x1m - x1) / 2, (x0 - x2) / 2]
  t += [(x2m - x1) / 3, (x1m - x2) / 3]
  t += [(x2m - x2) / 4]
  t += [y2m - y1m, y1m - y0, y0 - y1, y1 - y2]
  t += [(y2m - y0) / 2, (y1m - y1) / 2, (y0 - y2) / 2]
  t += [(y2m - y1) / 3, (y1m - y2) / 3]
  t += [(y2m - y2) / 4]
  t += [(x2m + y2m) / 4, (x2 + y2) / 4]
  t += [(x2m + 2 * y1m) / 4, (y1m + 2 * x2m) / 4, (x2 + 2 * y1) / 4, (y1 + 2 * x2) / 4]
  t += [(x1m + y1m) / 2, (x1 + y1) / 2]
  
  print(min([dd(time) for time in t]))
  
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"}]