Problem: The king is left alone on the chessboard. In spite of this loneliness, he doesn't lose heart, because he has business of national importance. For example, he has to pay an official visit to square t. As the king is not in habit of wasting his time, he wants to get from his current position s to square t in the least number of moves. Help him to do this.

<image>

In one move the king can get to the square that has a common side or a common vertex with the square the king is currently in (generally there are 8 different squares he can move to).

Input

The first line contains the chessboard coordinates of square s, the second line — of square t.

Chessboard coordinates consist of two characters, the first one is a lowercase Latin letter (from a to h), the second one is a digit from 1 to 8.

Output

In the first line print n — minimum number of the king's moves. Then in n lines print the moves themselves. Each move is described with one of the 8: L, R, U, D, LU, LD, RU or RD. 

L, R, U, D stand respectively for moves left, right, up and down (according to the picture), and 2-letter combinations stand for diagonal moves. If the answer is not unique, print any of them. 

Examples

Input

a8
h1


Output

7
RD
RD
RD
RD
RD
RD
RD

Solution (in PYTHON):

Solution:
from collections import defaultdict
final = []
class Node:
    def __init__(self, cargo=None, next=None):
        self.cargo = cargo
        self.next = next
    def __str__(self):
        return str(self.cargo)
class Queue:
    def __init__(self):
        self.length = 0
        self.head = None
        self.last = None
    def isEmpty(self):
        return (self.length == 0)
    
    def insert(self, cargo):
        node = Node(cargo)
        node.next = None
        if self.length == 0:
            #if list is empty the new node goes first
            self.head = self.last = node
        else:
            #find the last node in the list
            last = self.last
            #append the new node
            last.next = node
            self.last = node
        self.length = self.length + 1
        
    def remove(self):
        cargo = self.head.cargo
        self.head = self.head.next
        self.length = self.length - 1
        if self.length == 0:
            self.last = None
        return cargo
    def notin(self, cargo):
        if(self.head != None):
            temp = self.head
            while (temp != None):
                if(temp.cargo[0] == cargo[0]):
                    return False
                temp = temp.next
            return True
        else: return True
    def printq(self):
        if(self.head != None):
            temp = self.head
            while (temp != None):
                print temp.cargo,
                temp = temp.next
    
            
        
queue = Queue()
def notin(board, p1, p2):
    p = [p1,p2]
    for i in range(len(board)):
        if p == board[i][0]:
            return False
    return True

def assign(board, point):
    point, score = point
    if point[0]+1 <8 and notin(board, point[0]+1, point[1]) and queue.notin([[point[0]+1, point[1]], score+1]): #D
        queue.insert([[point[0]+1, point[1]], score+1])
    if point[1]+1 <8 and notin(board, point[0], point[1]+1) and queue.notin([[point[0], point[1]+1], score+1]): #R
        queue.insert([[point[0], point[1]+1], score+1])    
    if point[0]+1 <8 and point[1]+1 <8 and notin(board, point[0]+1, point[1]+1) and queue.notin([[point[0]+1, point[1]+1], score+1]): #RD
        queue.insert([[point[0]+1, point[1]+1], score+1])     
    if point[1]-1 >= 0 and notin(board, point[0], point[1]-1) and queue.notin([[point[0], point[1]-1], score+1]): #L
        queue.insert([[point[0], point[1]-1], score+1])            
    if point[0]-1 >= 0 and notin(board, point[0]-1, point[1]) and queue.notin([[point[0]-1, point[1]], score+1]): #U
        queue.insert([[point[0]-1, point[1]], score+1])        
    if point[0]-1 >= 0 and point[1]-1 >= 0 and notin(board, point[0]-1, point[1]-1) and queue.notin([[point[0]-1, point[1]-1], score+1]): #LU
        queue.insert([[point[0]-1, point[1]-1], score+1])    
    if point[0]-1 >= 0 and point[1]+1 < 8 and notin(board, point[0]-1, point[1]+1) and queue.notin([[point[0]-1, point[1]+1], score+1]): #RU
        queue.insert([[point[0]-1, point[1]+1], score+1])    
    if point[0]+1 < 8 and point[1]-1 >= 0 and notin(board, point[0]+1, point[1]-1) and queue.notin([[point[0]+1, point[1]-1], score+1]): #LD
        queue.insert([[point[0]+1, point[1]-1], score+1])    

def getadj(board, point):
    new = []
    if point[0]+1 <8: #D
        new.append([point[0]+1, point[1]])
    if point[1]+1 <8: #R
        new.append([point[0], point[1]+1])    
    if point[0]+1 <8 and point[1]+1 <8: #RD
        new.append([point[0]+1, point[1]+1])     
    if point[1]-1 >= 0: #L
        new.append([point[0], point[1]-1])            
    if point[0]-1 >= 0 : #U
        new.append([point[0]-1, point[1]])        
    if point[0]-1 >= 0 and point[1]-1 >= 0: #LU
        new.append([point[0]-1, point[1]-1])    
    if point[0]-1 >= 0 and point[1]+1 < 8: #RU
        new.append([point[0]-1, point[1]+1])    
    if point[0]+1 < 8 and point[1]-1 >= 0: #LD
        new.append([point[0]+1, point[1]-1])    
    return new

def goto(board, point, end):
    if [point[0]+1, point[1]] ==  end: #R
        final.append("R")
    if [point[0], point[1]+1] == end: #U
        final.append("U")
    if [point[0]+1, point[1]+1] == end: #RU
        final.append("RU")
    if [point[0], point[1]-1] == end: #D
        final.append("D")
    if [point[0]-1, point[1]] == end: #L
        final.append("L")
    if [point[0]-1, point[1]-1] == end: #LD
        final.append("LD")
    if [point[0]-1, point[1]+1] ==end: #LU
        final.append("LU")
    if [point[0]+1, point[1]-1] == end: #RD
        final.append("RD")

def getscore(board, point):
    for i in xrange(len(board)):
        if(point == board[i][0]):
            return board[i][1]

def printpath(board, start, end):
    if(start == end): return
    new = getadj(board, start)
    #print new
    minscore = 11
    mini = 0
    for i in xrange(len(new)):
        if getscore(board, new[i]) < minscore:
            mini = i
            minscore = getscore(board, new[i])
    goto(board, start, new[mini])
    printpath(board, new[mini], end)


    
import re
s = raw_input()
t = raw_input()
match = re.match(r"([a-h]+)([1-8]+)", s, re.I)
s = match.groups()
match = re.match(r"([a-h]+)([1-8]+)", t, re.I)
t = match.groups()
sl = []
tl = []
sl.append(ord(s[0]) - 97)
sl.append(int(s[1]) -1)
tl.append(ord(t[0]) - 97)
tl.append(int(t[1]) -1)

#print sl,tl

board = []
queue.insert([tl,1])
while(not queue.isEmpty()):
    next = queue.remove()
    #print
    #print next
    board.append(next)
    assign(board, next)
    #queue.printq()
#print sl,tl
printpath(board, sl, tl)
print len(final)
for i in xrange(len(final)):
    print final[i]