AtCoder Beginner Contest 051 - Back and Forth

Dolphin resides in two-dimensional Cartesian plane, with the positive x-axis pointing right and the positive y-axis pointing up.
Currently, he is located at the point (sx,sy). In each second, he can move up, down, left or right by a distance of 1.
Here, both the x- and y-coordinates before and after each movement must be integers.
He will first visit the point (tx,ty) where sx < tx and sy < ty, then go back to the point (sx,sy), then visit the point (tx,ty) again, and lastly go back to the point (sx,sy).
Here, during the whole travel, he is not allowed to pass through the same point more than once, except the points (sx,sy) and (tx,ty).
Under this condition, find a shortest path for him.

Constraints

* -1000 ≤ sx < tx ≤ 1000
* -1000 ≤ sy < ty ≤ 1000
* sx,sy,tx and ty are integers.

Input

The input is given from Standard Input in the following format:


sx sy tx ty


Output

Print a string S that represents a shortest path for Dolphin.
The i-th character in S should correspond to his i-th movement.
The directions of the movements should be indicated by the following characters:

* `U`: Up
* `D`: Down
* `L`: Left
* `R`: Right



If there exist multiple shortest paths under the condition, print any of them.

Examples

Input

0 0 1 2


Output

UURDDLLUUURRDRDDDLLU


Input

-2 -2 1 1


Output

UURRURRDDDLLDLLULUUURRURRDDDLLDL

Difficulty: UNKNOWN_DIFFICULTY

Starter code:

Solutions:
(A, B, X, Y) = map(int, input().split())
P = X - A
Q = Y - B
print('R' * P + 'U' * Q + 'L' * P + 'D' * Q + 'L' + 'U' * (Q + 1) + 'R' * (P + 1) + 'D' + 'R' + 'D' * (Q + 1) + 'L' * (P + 1) + 'U')


(sx, sy, tx, ty) = map(int, input().split())
print('U' * (ty - sy) + 'R' * (tx - sx) + 'D' * (ty - sy) + 'L' * (tx - sx) + 'LU' + 'U' * (ty - sy) + 'R' * (tx - sx) + 'RDRD' + 'D' * (ty - sy) + 'L' * (tx - sx) + 'LU')


(sx, sy, tx, ty) = map(int, input().split())
string = 'U' * (ty - sy) + 'R' * (tx - sx) + 'D' * (ty - sy) + 'L' * (tx - sx + 1) + 'U' * (ty - sy + 1) + 'R' * (tx - sx + 1) + 'D' + 'R' + 'D' * (ty - sy + 1) + 'L' * (tx - sx + 1) + 'U'
print(string)


(a, b, c, d) = map(int, input().split())
print('R' * (c - a) + 'U' * (d - b) + 'L' * (c - a) + 'D' * (d - b + 1) + 'R' * (c - a + 1) + 'U' * (d - b + 1) + 'L' + 'U' + 'L' * (c - a + 1) + 'D' * (d - b + 1) + 'R')


(a, b, c, d) = map(int, input().rstrip().split())
x = c - a
y = d - b
result1 = 'U' * y + 'R' * x
result2 = 'D' * y + 'L' * x
print(result1 + result2 + 'LU' + result1 + 'RD' + 'RD' + result2 + 'LU')


(sx, sy, tx, ty) = map(int, input().split())
(dx, dy) = (tx - sx, ty - sy)
print(dy * 'U' + dx * 'R' + dy * 'D' + dx * 'L' + 'L' + (dy + 1) * 'U' + (dx + 1) * 'R' + 'D' + 'R' + (dy + 1) * 'D' + (dx + 1) * 'L' + 'U')


(sx, sy, tx, ty) = map(int, input().split())
x = tx - sx
y = ty - sy
print('U' * y + 'R' * x + 'D' * y + 'L' * x + 'L' + 'U' * (y + 1) + 'R' * (x + 1) + 'DR' + 'D' * (y + 1) + 'L' * (x + 1) + 'U')


(a, b, c, d) = (int(i) for i in input().split())
(x, y) = (c - a, d - b)
print('R' * x + 'U' * y + 'L' * x + 'D' * (y + 1) + 'R' * (x + 1) + 'U' * (y + 1) + 'L' + 'U' + 'L' * (x + 1) + 'D' * (y + 1) + 'R')


(a, b, c, d) = map(int, input().split())
x = c - a
y = d - b
s = 'R' * x + 'U' * y
t = 'L' * x + 'D' * (y + 1) + 'R'
print(s + t + s + 'ULUL' + t)


(sx, sy, tx, ty) = map(int, input().split())
dx = tx - sx
dy = ty - sy
u = 'U'
d = 'D'
r = 'R'
l = 'L'
print(u * dy + r * dx + d * dy + l * dx + l + u * (dy + 1) + r * (dx + 1) + d + r + d * (dy + 1) + l * (dx + 1) + u)


(sx, sy, tx, ty) = map(int, input().split())
x = tx - sx
y = ty - sy
p1 = 'U' * y + 'R' * x
p2 = 'D' * y + 'L' * x
p3 = 'L' + 'U' * (y + 1) + 'R' * (x + 1) + 'D'
p4 = 'R' + 'D' * (y + 1) + 'L' * (x + 1) + 'U'
print(p1 + p2 + p3 + p4)


(sx, sy, tx, ty) = map(int, input().split())
X = tx - sx
Y = ty - sy
print('R' * X + 'U' * Y + 'L' * X + 'D' * (Y + 1) + 'R' * (X + 1) + 'U' * (Y + 1) + 'LU' + 'L' * (X + 1) + 'D' * (Y + 1) + 'R')


(sx, sy, tx, ty) = map(int, input().split())
x1 = tx - sx
y1 = ty - sy
print('U' * y1 + 'R' * x1 + 'D' * y1 + 'L' * x1 + 'L' + 'U' * (1 + y1) + 'R' * (1 + x1) + 'D' + 'R' + 'D' * (1 + y1) + 'L' * (1 + x1) + 'U')


(a, b, c, d) = map(int, input().split())
x = c - a
y = d - b
print('R' * x + 'U' * y + 'L' * x + 'D' * (y + 1) + 'R' * (x + 1) + 'U' * (y + 1) + 'LU' + 'L' * (x + 1) + 'D' * (y + 1) + 'R')


(sx, sy, tx, ty) = map(int, input().split())
h = ty - sy
w = tx - sx
print('L' + 'U' * (h + 1) + 'R' * (w + 1) + 'DR' + 'D' * (h + 1) + 'L' * (w + 1) + 'U' * (h + 1) + 'R' * w + 'D' * h + 'L' * w)


(SX, SY, TX, TY) = map(int, input().split())
x = TX - SX
y = TY - SY
print(''.join(['U' * y, 'R' * x, 'D' * y, 'L' * x, 'L', 'U' * (y + 1), 'R' * (x + 1), 'D', 'R', 'D' * (y + 1), 'L' * (x + 1), 'U']))


(x, y, p, q) = map(int, input().split())
print('U' * (q - y) + 'R' * (p - x) + 'D' * (q - y) + 'L' * (p - x + 1) + 'U' * (q - y + 1) + 'R' * (p - x + 1) + 'D' + 'R' + 'D' * (q - y + 1) + 'L' * (p - x + 1) + 'U')


(SX, SY, TX, TY) = map(int, input().split())
vx = TX - SX
vy = TY - SY
print('U' * vy + 'R' * vx + 'D' * vy + 'L' * vx + 'L' + 'U' * (vy + 1) + 'R' * (vx + 1) + 'D' + 'R' + 'D' * (vy + 1) + 'L' * (vx + 1) + 'U')


(s, t, x, y) = map(int, input().split())
x -= s
y -= t
r = 'R' * x + 'U' * -~y + 'L' * -~x + 'D' * y
print(r + 'DRDR' + r)


data = [int(i) for i in input().split()]
x = data[2] - data[0]
y = data[3] - data[1]
print('R' * x + 'U' * y + 'L' * x + 'D' * y + 'DR' + 'R' * x + 'U' * y + 'ULUL' + 'L' * x + 'D' * y + 'DR')


(sx, sy, tx, ty) = map(int, input().split())
(dx, dy) = (tx - sx, ty - sy)
st = 'U' * dy + 'R' * dx
ts = 'D' * dy + 'L' * dx
print(st + ts + 'LU' + st + 'RD' + 'RD' + ts + 'LU')


(x, y, xx, yy) = map(int, input().split())
x = xx - x
y = yy - y
print('R' * x + 'U' * y + 'L' * x + 'D' * (y + 1) + 'R' * (x + 1) + 'U' * (y + 1) + 'LU' + 'L' * (x + 1) + 'D' * (y + 1) + 'R')


a = list(map(int, input().split()))
(b, c) = (a[2] - a[0], a[3] - a[1])
(d, e) = (b + 1, c + 1)
print('R' * b + 'U' * c + 'L' * b + 'D' * c + 'D' + 'R' * d + 'U' * e + 'L' + 'U' + 'L' * d + 'D' * e + 'R', end='')


(sx, sy, tx, ty) = map(int, input().split())
xd = tx - sx
yd = ty - sy
res = 'R' * xd + 'U' * yd + 'L' * xd + 'D' * yd + 'D' + 'R' * (xd + 1) + 'U' * (yd + 1) + 'LU' + 'L' * (xd + 1) + 'D' * (yd + 1) + 'R'
print(res)


(sx, sy, tx, ty) = map(int, input().split())
dx = tx - sx
dy = ty - sy
r1 = 'R' * dx + 'U' * dy
r2 = 'L' * dx + 'D' * dy
r3 = 'D' + 'R' * (dx + 1) + 'U' * (dy + 1) + 'L'
r4 = 'U' + 'L' * (dx + 1) + 'D' * (dy + 1) + 'R'
print(r1 + r2 + r3 + r4)


(sx, sy, tx, ty) = map(int, input().split())
dx = tx - sx
dy = ty - sy
a = 'U' * dy + 'R' * dx
b = 'D' * dy + 'L' * dx
c = 'L' + 'U' * (dy + 1) + 'R' * (dx + 1) + 'D'
d = 'R' + 'D' * (dy + 1) + 'L' * (dx + 1) + 'U'
print(a + b + c + d)


(sx, sy, tx, ty) = map(int, input().split())
x = tx - sx
y = ty - sy
n1 = 'U' * y + 'R' * x + 'D' * y + 'L' * x
n2 = 'L' + 'U' * (y + 1) + 'R' * (x + 1) + 'D'
n3 = 'R' + 'D' * (y + 1) + 'L' * (x + 1) + 'U'
print(n1 + n2 + n3)


(x1, y1, x2, y2) = map(int, input().split())
x = abs(x1 - x2)
y = abs(y1 - y2)
print(x * 'R' + y * 'U' + x * 'L' + y * 'D' + 'D' + (x + 1) * 'R' + (y + 1) * 'U' + 'L' + 'U' + (x + 1) * 'L' + (y + 1) * 'D' + 'R')


(sx, sy, tx, ty) = map(int, input().split())
(x, y) = (tx - sx, ty - sy)
print('R' * x + 'U' * y + 'L' * x + 'D' * -~y + 'R' * -~x + 'U' * -~y + 'LU' + 'L' * -~x + 'D' * -~y + 'R')


(sx, sy, tx, ty) = list(map(int, input().split()))
x = tx - sx
y = ty - sy
answer = 'L' + 'U' * (y + 1) + 'R' * (x + 1) + 'D' + 'L' * x + 'D' * y + 'R' * x + 'U' * y + 'R' + 'D' * (y + 1) + 'L' * (x + 1) + 'U'
print(answer)


(x1, y1, x2, y2) = map(int, input().split())
x = x2 - x1
y = y2 - y1
s = 'R' * x + 'U' * y + 'L' * x + 'D' * (y + 1) + 'R' * (x + 1) + 'U' * (y + 1) + 'LU' + 'L' * (x + 1) + 'D' * (y + 1) + 'R'
print(s)


(sx, sy, gx, gy) = map(int, input().split())
(dx, dy) = (gx - sx, gy - sy)
print('U' * dy + 'R' * dx + 'D' * dy + 'L' * dx + 'L' + 'U' * (dy + 1) + 'R' * (dx + 1) + 'D' + 'R' + 'D' * (dy + 1) + 'L' * (dx + 1) + 'U')


(a, b, x, y) = map(int, input().split())
(r, c) = (y - b, x - a)
(R, L, U, D) = 'RLUD'
print(R * c + U * r + L * c + D * -~r + R * -~c + U * -~r + L + U + L * -~c + D * -~r + R)


(sx, sy, tx, ty) = map(int, input().split(' '))
r1 = 'R' * (tx - sx)
r2 = 'U' * (ty - sy)
r3 = 'L' * (tx - sx)
r4 = 'D' * (ty - sy)
r = r1 + r2 + r3 + r4 + 'D' + r1 + 'RU' + r2 + 'L' + 'U' + r3 + 'LD' + r4 + 'R'
print(r)


(x, y, a, b) = map(int, input().split())
print('R' * (a - x) + 'U' * (b - y) + 'L' * (a - x) + 'D' * (b - y) + 'D' + 'R' * (a - x + 1) + 'U' * (b - y + 1) + 'L' + 'U' + 'L' * (a - x + 1) + 'D' * (b - y + 1) + 'R')


(x, y, u, v) = map(int, input().split())
p = u - x
q = v - y
S = 'U' * q + 'R' * p + 'D' * q
S += 'L' * (p + 1) + 'U' * (q + 1) + 'R' * (p + 1) + 'D' + 'R' + 'D' * (q + 1) + 'L' * (p + 1) + 'U'
print(S)


(A, B, C, D) = map(int, input().split())
P = 'R' * (C - A)
P += 'U' * (D - B)
P += 'L' * (C - A)
P += 'D' * (D - B + 1)
P += 'R' * (C - A + 1)
P += 'U' * (D - B + 1)
P += 'L'
P += 'U'
P += 'L' * (C - A + 1)
P += 'D' * (D - B + 1)
print(P + 'R')


(sx, sy, tx, ty) = map(int, input().split())
a = (tx - sx) * 'R' + (ty - sy) * 'U'
b = (tx - sx) * 'L' + (ty - sy) * 'D'
print(a + b + 'DR' + a + 'ULUL' + b + 'DR')


(sx, sy, tx, ty) = map(int, input().split())
a = tx - sx
b = ty - sy
ans = ''
ans = 'U' * b + 'R' * a
ans += 'D' * b + 'L' * a
ans += 'D' + 'R' * (a + 1) + 'U' * (b + 1) + 'L'
ans += 'U' + 'L' * (a + 1) + 'D' * (b + 1) + 'R'
print(ans)


(a, b, c, d) = map(int, input().split())
(x, y) = (c - a, d - b)
(u, d, l, r) = 'UDLR'
print(u * y + r * x + d * y + l * x + l + u * (y + 1) + r * (x + 1) + d + r + d * (y + 1) + l * (x + 1) + u)


(sx, sy, tx, ty) = map(int, input().split())
mx = tx - sx
my = ty - sy
print('U' * my + 'R' * mx + 'D' * my + 'L' * mx + 'L' + 'U' * (my + 1) + 'R' * (mx + 1) + 'DR' + 'D' * (my + 1) + 'L' * (mx + 1) + 'U')


(x, y, u, v) = map(int, input().split())
x = u - x
y = v - y
ans = 'L' + 'U' * (y + 1) + 'R' * (x + 1) + 'D'
ans += 'L' * x + 'D' * y
ans += 'R' * x + 'U' * y
ans += 'R' + 'D' * (y + 1) + 'L' * (x + 1) + 'U'
print(ans)


(sx, sy, tx, ty) = map(int, input().split())
x = tx - sx
y = ty - sy
l = ['R'] * x + ['U'] * y + ['L'] * x + ['D'] * y + ['D'] + ['R'] * (x + 1) + ['U'] * (y + 1) + ['L'] + ['U'] + ['L'] * (x + 1) + ['D'] * (y + 1) + ['R']
print(''.join(l))


(sx, sy, tx, ty) = map(int, input().split())
yoko = tx - sx
tate = ty - sy
print('U' * tate + 'R' * yoko + 'D' * tate + 'L' * yoko + 'L' + 'U' * (tate + 1) + 'R' * (yoko + 1) + 'D' + 'R' + 'D' * (tate + 1) + 'L' * (yoko + 1) + 'U')


(sx, sy, tx, ty) = map(int, input().strip().split(' '))
print('U' * (ty - sy) + 'R' * (tx - sx + 1) + 'D' * (ty - sy + 1) + 'L' * (tx - sx + 1) + 'UL' + 'U' * (ty - sy + 1) + 'R' * (tx - sx + 1) + 'D' * (ty - sy + 1) + 'L' * (tx - sx))


(p, q, r, s) = map(int, input().split())
x = r - p
y = s - q
uy = 'U' * y
print(uy + 'R' * x + 'D' * y + 'L' * x + 'L' + uy + 'U' + 'R' * (x + 1) + 'D' + 'R' + 'D' * (y + 1) + 'L' * (x + 1) + 'U')


(sx, sy, gx, gy) = map(int, input().split())
(x, y) = (gx - sx, gy - sy)
print('U' * y + 'R' * x + 'D' * y + 'L' * (x + 1) + 'U' * (y + 1) + 'R' * (x + 1) + 'D' * 1 + 'R' * 1 + 'D' * (y + 1) + 'L' * (x + 1) + 'U' * 1)


xy = [int(i) for i in input().split()]
a = abs(xy[2] - xy[0])
b = abs(xy[3] - xy[1])
ans = 'U' * b + 'R' * a + 'D' * b + 'L' * a + 'L' + 'U' * (b + 1) + 'R' * (a + 1) + 'D' + 'R' + 'D' * (b + 1) + 'L' * (a + 1) + 'U'
print(ans)


(sx, sy, tx, ty) = map(int, input().split())
m1 = (tx - sx) * 'R' + (ty - sy) * 'U'
m2 = (tx - sx) * 'L' + (ty - sy) * 'D'
print(m1 + m2 + 'DR' + m1 + 'ULUL' + m2 + 'DR')


(sx, sy, tx, ty) = [int(x) for x in input().split()]
dx = tx - sx
dy = ty - sy
print('R' * dx + 'U' * dy + 'L' * dx + 'D' * (dy + 1) + 'R' * (dx + 1) + 'U' * (dy + 1) + 'L' + 'U' + 'L' * (dx + 1) + 'D' * (dy + 1) + 'R')


(x1, y1, x2, y2) = map(int, input().split())
(W, H) = (x2 - x1, y2 - y1)
print('R' * W + 'U' * H + 'L' * W + 'D' * H + 'D' + 'R' * (W + 1) + 'U' * (H + 1) + 'LU' + 'L' * (W + 1) + 'D' * (H + 1) + 'R')


(SX, SY, TX, TY) = (int(T) for T in input().split())
print('R' * (TX - SX) + 'U' * (TY - SY) + 'L' * (TX - SX) + 'D' * (TY - SY) + 'D' + 'R' * (TX - SX + 1) + 'U' * (TY - SY + 1) + 'L' + 'U' + 'L' * (TX - SX + 1) + 'D' * (TY - SY + 1) + 'R')


(a0, b0, a1, b1) = map(int, input().split())
[x, y] = [a1 - a0, b1 - b0]
print('U' * y + 'R' * x + 'D' * y + 'L' * x + 'D' + 'R' * (x + 1) + 'U' * (y + 1) + 'LU' + 'L' * (x + 1) + 'D' * (y + 1) + 'R')


(sx, sy, tx, ty) = map(int, input().split())
a = tx - sx
b = ty - sy
r1 = 'R' * a + 'U' * b
r2 = 'L' * a + 'D' * b
r3 = 'D' + 'R' * (a + 1) + 'U' * (b + 1) + 'L'
r4 = 'U' + 'L' * (a + 1) + 'D' * (b + 1) + 'R'
print(r1 + r2 + r3 + r4)


(sx, sy, tx, ty) = map(int, input().split(' '))
h = ty - sy
w = tx - sx
p = 'U' * h + 'R' * w
r = 'D' * h + 'L' * w
print(p + r + 'LU' + p + 'RDRD' + r + 'LU')


(m1, m2, n1, n2) = map(int, input().split())
n = n1 - m1
m = n2 - m2
ans = ''
go = 'U' * m + 'R' * n
back = 'D' * m + 'L' * n
a1 = 'LU'
a2 = 'RDRD'
a3 = 'LU'
print(go + back + a1 + go + a2 + back + a3)


(sx, sy, tx, ty) = map(int, input().split())
xdif = tx - sx
ydif = ty - sy
S = 'R' * xdif + 'U' * ydif + 'L' * xdif + 'D' * ydif
S = S + 'D' + 'R' * (xdif + 1) + 'U' * (ydif + 1) + 'LU' + 'L' * (xdif + 1) + 'D' * (ydif + 1) + 'R'
print(S)


(sx, sy, tx, ty) = map(int, input().split())
x = tx - sx
y = ty - sy
ans = ''
go = 'U' * y + 'R' * x
back = 'D' * y + 'L' * x
a1 = 'LU'
a2 = 'RDRD'
a3 = 'LU'
print(go + back + a1 + go + a2 + back + a3)


(sx, sy, tx, ty) = map(int, input().split())
dx = tx - sx
dy = ty - sy
R1 = 'U' * dy + 'R' * dx
R2 = 'D' * dy + 'L' * dx
R3 = 'L' + 'U' * (dy + 1) + 'R' * (dx + 1) + 'D'
R4 = 'R' + 'D' * (dy + 1) + 'L' * (dx + 1) + 'U'
print(R1 + R2 + R3 + R4)


(sx, sy, tx, ty) = map(int, input().split())
TSX = tx - sx
TSY = ty - sy
print('U' * TSY + 'R' * TSX + 'D' * TSY + 'L' * TSX + 'D' + 'R' * (TSX + 1) + 'U' * (TSY + 1) + 'L' + 'U' + 'L' * (TSX + 1) + 'D' * (TSY + 1) + 'R')


(x1, y1, x2, y2) = map(int, input().split())
(X, Y) = (x2 - x1, y2 - y1)
print('U' * Y + 'R' * X + 'D' * Y + 'L' * X + 'L' + 'U' * (Y + 1) + 'R' * (X + 1) + 'D' + 'R' + 'D' * (Y + 1) + 'L' * (X + 1) + 'U')


(a, b, c, d) = map(int, input().split())
X = c - a
Y = d - b
ans1 = 'R' * X + 'U' * Y
ans2 = 'L' * X + 'D' * Y
ans3 = 'D' + 'R' * (X + 1) + 'U' * (Y + 1) + 'L'
ans4 = 'U' + 'L' * (X + 1) + 'D' * (Y + 1) + 'R'
print(ans1 + ans2 + ans3 + ans4)


(sx, sy, tx, ty) = map(int, input().split())
x = tx - sx
y = ty - sy
a = 'R' * x + 'U' * y
b = 'L' * x + 'D' * y
c = 'D' + 'R' * (x + 1) + 'U' * (y + 1) + 'L'
d = 'U' + 'L' * (x + 1) + 'D' * (y + 1) + 'R'
print(a + b + c + d)


(sx, sy, tx, ty) = map(int, input().split())
(ax, ay) = (tx - sx, ty - sy)
print('U' * ay + 'R' * ax + ('D' * ay + 'L' * ax) + ('L' + 'U' * (ay + 1) + 'R' * (ax + 1) + 'D') + ('R' + 'D' * (ay + 1) + 'L' * (ax + 1) + 'U'))


(s, t, x, y) = map(int, input().split())
x -= s
y -= t
print('R' * x + 'U' * y + 'L' * x + 'D' * -~y + 'R' * -~x + 'U' * -~y + 'LU' + 'L' * -~x + 'D' * -~y + 'R')


(a, b, c, d) = map(int, input().split())
l = 'URDL'
(e, f) = (d - b, c - a)
print(''.join([l[i] * e + l[i + 1] * f for i in [0, 2]] + [l[(j + 3) % 4] + l[j] * (e + 1) + l[j + 1] * (f + 1) + l[(j + 2) % 4] for j in [0, 2]]))


(a, b, c, d) = map(int, input().split())
x = c - a
y = d - b
s = ['U'] * y + ['R'] * x
t = ['D'] * y + ['L'] * x
q = s + t + ['L'] + ['U'] + s + ['R'] + ['D'] + ['R'] + ['D'] + t + ['L'] + ['U']
print(''.join(q))


(sx, sy, tx, ty) = list(map(int, input().split()))
ans = 'U' * (ty - sy) + 'R' * (tx - sx) + 'D' * (ty - sy) + 'L' * (tx - sx + 1) + 'U' * (ty - sy + 1) + 'R' * (tx - sx + 1) + 'D' + 'R' + 'D' * (ty - sy + 1) + 'L' * (tx - sx + 1) + 'U'
print(ans)


(p, q, x, y) = map(int, input().split())
x -= p
y -= q
u = 'U' * y + 'R' * x
d = 'D' * y + 'L' * x + 'LU'
print(u + d + u + 'RDRD' + d)


(sx, sy, tx, ty) = (int(i) for i in input().split())
w = tx - sx
h = ty - sy
res = 'U' * h + 'R' * w + 'D' * h + 'L' * (w + 1) + 'U' * (h + 1) + 'R' * (w + 1) + 'DR' + 'D' * (h + 1) + 'L' * (w + 1) + 'U'
print(res)


(sx, sy, tx, ty) = map(int, input().split())
ue = ty - sy
migi = tx - sx
print('U' * ue + 'R' * migi + 'D' * ue + 'L' * (migi + 1) + 'U' * (ue + 1) + 'R' * (migi + 1) + 'D' + 'R' + 'D' * (ue + 1) + 'L' * (migi + 1) + 'U')


(sx, sy, tx, ty) = map(int, input().split())
(tx2, ty2) = (tx - sx, ty - sy)
a1 = 'U' * ty2 + 'R' * tx2 + 'D' * ty2 + 'L' * tx2
a2 = 'L' + 'U' * (ty2 + 1) + 'R' * (tx2 + 1) + 'DR' + 'D' * (ty2 + 1) + 'L' * (tx2 + 1) + 'U'
print(a1 + a2)


(sx, sy, tx, ty) = map(int, input().split())
(dx, dy) = (tx - sx, ty - sy)
s1 = 'U' * dy + 'R' * dx + 'D' * dy + 'L' * dx
s2 = 'LU' + 'U' * dy + 'R' * dx + 'RD' + 'RD' + 'D' * dy + 'L' * dx + 'LU'
print(s1 + s2)


(a, b, c, d) = map(int, input().split())
x = c - a
y = d - b
print('U' * y + 'R' * x + 'D' * y + 'L' * -~x + 'U' * -~y + 'R' * -~x + 'DR' + 'D' * -~y + 'L' * -~x + 'U')


(sx, sy, tx, ty) = map(int, input().split())
(X, Y, U, D, L, R) = (tx - sx, ty - sy, 'U', 'D', 'L', 'R')
(XX, YY) = (X + 1, Y + 1)
print(D + R * XX + U * YY + L * XX + D * Y + R * X + U * YY + L * XX + D * YY + R)