output_description: If the condition can be satisfied, follow the following format. If the
  condition cannot be satisfied, print `-1`.
  
      
      
      m
      d_1 d_2 ... d_m
      w_1
      w_2
      :
      w_N
      
  
  m and d_i are the configurations of the robot arm. Refer to the problem
  statement for what each of them means. Here, 1 \leq m \leq 40 and 1 \leq d_i
  \leq 10^{12} must hold. Also, m and d_i must all be integers.
  
  w_j is a string of length m that represents the way to bring Joint m of the
  robot arm to point (X_j, Y_j). The i-th character of w_j should be one of the
  letters `L`, `R`, `D` and `U`, representing the mode of Section i.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      X_1 Y_1
      X_2 Y_2
      :
      X_N Y_N
attempt: ###############################################################################
  
  from sys import stdout
  from bisect import bisect_left as binl
  from copy import copy, deepcopy
  
  
  def intin():
      input_tuple = input().split()
      if len(input_tuple) <= 1:
          return int(input_tuple[0])
      return tuple(map(int, input_tuple))
  
  
  def intina():
      return [int(i) for i in input().split()]
  
  
  def intinl(count):
      return [intin() for _ in range(count)]
  
  
  def modadd(x, y):
      global mod
      return (x + y) % mod
  
  
  def modmlt(x, y):
      global mod
      return (x * y) % mod
  
  
  def lcm(x, y):
      while y != 0:
          z = x % y
          x = y
          y = z
      return x
  
  
  def get_divisors(x):
      retlist = []
      for i in range(1, int(x**0.5) + 3):
          if x % i == 0:
              retlist.append(i)
              retlist.append(x // i)
      return retlist
  
  
  def make_linklist(xylist):
      linklist = {}
      for a, b in xylist:
          linklist.setdefault(a, [])
          linklist.setdefault(b, [])
          linklist[a].append(b)
          linklist[b].append(a)
      return linklist
  
  
  def calc_longest_distance(linklist, v=1):
      distance_list = {}
      distance_count = 0
      distance = 0
      vlist_previous = []
      vlist = [v]
      nodecount = len(linklist)
  
      while distance_count < nodecount:
          vlist_next = []
          for v in vlist:
              distance_list[v] = distance
              distance_count += 1
              vlist_next.extend(linklist[v])
          distance += 1
          vlist_to_del = vlist_previous
          vlist_previous = vlist
          vlist = list(set(vlist_next) - set(vlist_to_del))
  
      max_distance = -1
      max_v = None
      for v, distance in distance_list.items():
          if distance > max_distance:
              max_distance = distance
              max_v = v
  
      return (max_distance, max_v)
  
  
  def calc_tree_diameter(linklist, v=1):
      _, u = calc_longest_distance(linklist, v)
      distance, _ = calc_longest_distance(linklist, u)
      return distance
  
  
  ###############################################################################
  
  
  def main():
      n = intin()
      xylist = intinl(n)
  
      even_odd = None
      uvlist = []
  
      for x, y in xylist:
          tmp_even_odd = (x + y) % 2
  
          if even_odd is None:
              even_odd = tmp_even_odd
  
          if even_odd != tmp_even_odd:
              print(-1)
              return
  
          uvlist.append((x + y, x - y))
  
      m = 33 if even_odd else 34
  
      print(m)
      dlist = [str(2**i) for i in reversed(list(range(0, 33)))]
      if not even_odd:
          dlist.append("1")
      print(" ".join(dlist))
  
      for u, v in uvlist:
  
          if not even_odd:
              u += 1
              v += 1
          line = ""
  
          if u >= 0 and v >= 0:
              line += "R"
          if u >= 0 and v < 0:
              line += "U"
          if u < 0 and v >= 0:
              line += "D"
          if u < 0 and v < 0:
              line += "L"
  
          for i in reversed(list(range(1, 33))):
              u_bit = (u >> i) & 1
              v_bit = (v >> i) & 1
              if u_bit and v_bit:
                  line += "R"
              if u_bit and not v_bit:
                  line += "U"
              if not u_bit and v_bit:
                  line += "D"
              if not u_bit and not v_bit:
                  line += "L"
  
          if not even_odd:
              line += "L"
  
          print(line)
  
  
  if __name__ == "__main__":
      main()
  
problem_description: Statement
  
  Snuke is introducing a **robot arm** with the following properties to his
  factory:
  
    * The robot arm consists of m **sections** and m+1 **joints**. The sections are numbered 1, 2, ..., m, and the joints are numbered 0, 1, ..., m. Section i connects Joint i-1 and Joint i. The length of Section i is d_i.
    * For each section, its **mode** can be specified individually. There are four modes: `L`, `R`, `D` and `U`. The mode of a section decides the direction of that section. If we consider the factory as a coordinate plane, the position of Joint i will be determined as follows (we denote its coordinates as (x_i, y_i)):
      * (x_0, y_0) = (0, 0).
      * If the mode of Section i is `L`, (x_{i}, y_{i}) = (x_{i-1} - d_{i}, y_{i-1}).
      * If the mode of Section i is `R`, (x_{i}, y_{i}) = (x_{i-1} + d_{i}, y_{i-1}).
      * If the mode of Section i is `D`, (x_{i}, y_{i}) = (x_{i-1}, y_{i-1} - d_{i}).
      * If the mode of Section i is `U`, (x_{i}, y_{i}) = (x_{i-1}, y_{i-1} + d_{i}).
  
  Snuke would like to introduce a robot arm so that the position of Joint m can
  be matched with all of the N points (X_1, Y_1), (X_2, Y_2), ..., (X_N, Y_N) by
  properly specifying the modes of the sections. Is this possible? If so, find
  such a robot arm and how to bring Joint m to each point (X_j, Y_j).
samples: [{"input": "3\n    -1 0\n    0 3\n    2 -1", "output": "2\n    1 2\n    RL\n    UU\n    DR\n    \n\nIn the given way to bring Joint m of the robot arm to each (X_j, Y_j), the\npositions of the joints will be as follows:\n\n  * To (X_1, Y_1) = (-1, 0): First, the position of Joint 0 is (x_0, y_0) = (0, 0). As the mode of Section 1 is `R`, the position of Joint 1 is (x_1, y_1) = (1, 0). Then, as the mode of Section 2 is `L`, the position of Joint 2 is (x_2, y_2) = (-1, 0).\n  * To (X_2, Y_2) = (0, 3): (x_0, y_0) = (0, 0), (x_1, y_1) = (0, 1), (x_2, y_2) = (0, 3).\n  * To (X_3, Y_3) = (2, -1): (x_0, y_0) = (0, 0), (x_1, y_1) = (0, -1), (x_2, y_2) = (2, -1).\n\n* * *"}, {"input": "5\n    0 0\n    1 0\n    2 0\n    3 0\n    4 0", "output": "-1\n    \n\n* * *"}, {"input": "2\n    1 1\n    1 1", "output": "2\n    1 1\n    RU\n    UR\n    \n\nThere may be duplicated points among (X_j, Y_j).\n\n* * *"}, {"input": "3\n    -7 -3\n    7 3\n    -3 -7", "output": "5\n    3 1 4 1 5\n    LRDUL\n    RDULR\n    DULRD"}]