;; -*- coding: utf-8 -*-
(eval-when (:compile-toplevel :load-toplevel :execute)
  (sb-int:defconstant-eqx OPT
    #+swank '(optimize (speed 3) (safety 2))
    #-swank '(optimize (speed 3) (safety 0) (debug 0))
    #'equal)
  #+swank (ql:quickload '(:cl-debug-print :fiveam) :silent t)
  #-swank (set-dispatch-macro-character
           ;; enclose the form with VALUES to avoid being captured by LOOP macro
           #\# #\> (lambda (s c p) (declare (ignore c p)) `(values ,(read s nil nil t)))))
#+swank (cl-syntax:use-syntax cl-debug-print:debug-print-syntax)
#-swank (disable-debugger) ; for CS Academy

;; BEGIN_INSERTED_CONTENTS
(defmacro dbg (&rest forms)
  #+swank
  (if (= (length forms) 1)
      `(format *error-output* "~A => ~A~%" ',(car forms) ,(car forms))
      `(format *error-output* "~A => ~A~%" ',forms `(,,@forms)))
  #-swank (declare (ignore forms)))

(defmacro define-int-types (&rest bits)
  `(progn
     ,@(mapcar (lambda (b) `(deftype ,(intern (format nil "UINT~A" b)) () '(unsigned-byte ,b))) bits)
     ,@(mapcar (lambda (b) `(deftype ,(intern (format nil "INT~A" b)) () '(signed-byte ,b))) bits)))
(define-int-types 2 4 7 8 15 16 31 32 62 63 64)

(declaim (inline println))
(defun println (obj &optional (stream *standard-output*))
  (let ((*read-default-float-format* 'double-float))
    (prog1 (princ obj stream) (terpri stream))))

(defconstant +mod+ 1000000007)

;;;
;;; Body
;;;

(defun %solve (x y)
  (assert (oddp x))
  (let ((res-x (make-array 36 :element-type 'int32))
        (res-y (make-array 36 :element-type 'int32))
        (res (make-string 36 :element-type 'base-char)))
    (loop for e from 35 downto 0
          for base = (expt 2 e)
          do (cond ((> x 0)
                    (decf x base)
                    (setf (aref res-x e) 1))
                   ((< x 0)
                    (incf x base)
                    (setf (aref res-x e) -1))
                   (t (error "Huh?")))
             (cond ((> y 0)
                    (decf y base)
                    (setf (aref res-y e) 1))
                   ((< y 0)
                    (incf y base)
                    (setf (aref res-y e) -1))
                   (t (error "Huh?"))))
    (assert (zerop x))
    (assert (zerop y))
    (dotimes (e 36)
      (let ((x (aref res-x e))
            (y (aref res-y e)))
        (cond ((and (= x 1) (= y 1))
               (setf (aref res e) #\R))
              ((and (= x 1) (= y -1))
               (setf (aref res e) #\U))
              ((and (= x -1) (= y -1))
               (setf (aref res e) #\L))
              ((and (= x -1) (= y 1))
               (setf (aref res e) #\D))
              (t (error "Huh?")))))
    res))

(defun solve (x y)
  (let ((x+y (+ x y))
        (x-y (- x y)))
    (if (oddp x+y)
        (%solve x+y x-y)
        (let ((res (%solve (- x+y 1) (+ x-y 1))))
          (concatenate 'string res "U")))))

(defun main ()
  (let* ((n (read))
         (xs (make-array n :element-type 'int32))
         (ys (make-array n :element-type 'int32)))
    (dotimes (i n)
      (setf (aref xs i) (read)
            (aref ys i) (read)))
    (unless (or (every (lambda (x y) (oddp (+ x y))) xs ys)
                (every (lambda (x y) (evenp (+ x y))) xs ys))
      (println -1)
      (return-from main))
    (if (oddp (+ (aref xs 0) (aref ys 0)))
        (format t "36
1 2 4 8 16 32 64 128 256 512 1024 2048 4096 8192 16384 32768 65536 131072 262144 524288 1048576 2097152 4194304 8388608 16777216 33554432 67108864 134217728 268435456 536870912 1073741824 2147483648 4294967296 8589934592 17179869184 34359738368
")
        (format t "37
1 2 4 8 16 32 64 128 256 512 1024 2048 4096 8192 16384 32768 65536 131072 262144 524288 1048576 2097152 4194304 8388608 16777216 33554432 67108864 134217728 268435456 536870912 1073741824 2147483648 4294967296 8589934592 17179869184 34359738368 1
"))
    (dotimes (i n)
      (write-line (solve (aref xs i) (aref ys i))))))

#-swank (main)

;;;
;;; Test and benchmark
;;;

#+swank
(defun io-equal (in-string out-string &key (function #'main) (test #'equal))
  "Passes IN-STRING to *STANDARD-INPUT*, executes FUNCTION, and returns true if
the string output to *STANDARD-OUTPUT* is equal to OUT-STRING."
  (labels ((ensure-last-lf (s)
             (if (eql (uiop:last-char s) #\Linefeed)
                 s
                 (uiop:strcat s uiop:+lf+))))
    (funcall test
             (ensure-last-lf out-string)
             (with-output-to-string (out)
               (let ((*standard-output* out))
                 (with-input-from-string (*standard-input* (ensure-last-lf in-string))
                   (funcall function)))))))

#+swank
(defun get-clipbrd ()
  (with-output-to-string (out)
    ;; (run-program "C:/Windows/System32/WindowsPowerShell/v1.0/powershell.exe" '("get-clipboard") :output out)
    (run-program "powershell.exe" '("-Command" "Get-Clipboard") :output out :search t)))

#+swank (defparameter *this-pathname* (uiop:current-lisp-file-pathname))
#+swank (defparameter *dat-pathname* (uiop:merge-pathnames* "test.dat" *this-pathname*))

#+swank
(defun run (&optional thing (out *standard-output*))
  "THING := null | string | symbol | pathname

null: run #'MAIN using the text on clipboard as input.
string: run #'MAIN using the string as input.
symbol: alias of FIVEAM:RUN!.
pathname: run #'MAIN using the text file as input."
  (let ((*standard-output* out))
    (etypecase thing
      (null
       (with-input-from-string (*standard-input* (delete #\Return (get-clipbrd)))
         (main)))
      (string
       (with-input-from-string (*standard-input* (delete #\Return thing))
         (main)))
      (symbol (5am:run! thing))
      (pathname
       (with-open-file (*standard-input* thing)
         (main))))))

#+swank
(defun gen-dat ()
  (uiop:with-output-file (out *dat-pathname* :if-exists :supersede)
    (format out "")))

#+swank
(defun bench (&optional (out (make-broadcast-stream)))
  (time (run *dat-pathname* out)))

;; To run: (5am:run! :sample)
#+swank
(it.bese.fiveam:test :sample
  (it.bese.fiveam:is
   (common-lisp-user::io-equal "3
-1 0
0 3
2 -1
"
    "2
1 2
RL
UU
DR
"))
  (it.bese.fiveam:is
   (common-lisp-user::io-equal "5
0 0
1 0
2 0
3 0
4 0
"
    "-1
"))
  (it.bese.fiveam:is
   (common-lisp-user::io-equal "2
1 1
1 1
"
    "2
1 1
RU
UR
"))
  (it.bese.fiveam:is
   (common-lisp-user::io-equal "3
-7 -3
7 3
-3 -7
"
    "5
3 1 4 1 5
LRDUL
RDULR
DULRD
")))


Measured memory_bytes: 26724