class node:
    def __init__(self):
        self.i=None
        self.j=None
        self.h=None
        self.parent=None
        self.move=None
        
class pathnode:
    def __init__(self):
        self.a=[]
        self.length=len(self.a)
        
class redknight_chess:
    def __init__(self,n,s,e):
        self.start=s
        self.end=e
        self.start.h=self.heuristic(self.start)
        self.end.h=self.heuristic(self.end)
        self.n=n
        self.openx=[]
        self.openx.append(s)
        self.paths=[None for i in range(100)]
        self.closex=[]

    def search(self):
        k=0
        while len(self.openx)>0:
            
            if k==5 :
                return
            x=self.openx[0]
            del self.openx[0]
            self.closex.append(x)
            if x.i==self.end.i and x.j==self.end.j :
                #print(x.i,x.j,"went once")
                self.printpath(x)
                k=k+1
            adj=self.movegen(x)
            #print(len(adj))
            adjr=self.removeseen(adj)
            #print(len(adjr),"adjr")
            self.openx=self.openx+adjr

    def movegen(self,e):
        #print(e.h,"e.h",e.move,"-----------------")
        m=e.i
        n=e.j
        move=[]
        p=m-1
        q=n-2
        nod=node()
        nod.i=p
        nod.j=q
        if p >= 0 and q >= 0 and p < self.n and q < self.n :
            nod.h=self.heuristic(nod)
            nod.parent=e
            nod.move='UL'
            #print(nod.move,nod.h,"(",nod.i,",",nod.j,")")
            if nod.h <e.h :
                move.append(nod)
                
        p=m+1
        q=n-2
        nod=node()
        nod.i=p
        nod.j=q
        if p >= 0 and q >= 0 and p < self.n and q < self.n :
            nod.h=self.heuristic(nod)
            nod.parent=e
            nod.move='UR'
            #print(nod.move,nod.h,"(",nod.i,",",nod.j,")")
            if nod.h <e.h :
                move.append(nod)


        p=m+2
        q=n
        nod=node()
        nod.i=p
        nod.j=q
        if p >= 0 and q >= 0 and p < self.n and q < self.n :
            nod.h=self.heuristic(nod)
            nod.parent=e
            nod.move='R'
            #print(nod.move,nod.h,"(",nod.i,",",nod.j,")")
            if nod.h <e.h :
                move.append(nod)


        p=m+1
        q=n+2
        nod=node()
        nod.i=p
        nod.j=q
        if p >= 0 and q >= 0 and p < self.n and q < self.n :
            nod.h=self.heuristic(nod)
            nod.parent=e
            nod.move='LR'
            #print(nod.move,nod.h,"(",nod.i,",",nod.j,")")
            if nod.h <e.h :
                move.append(nod)


        p=m-1
        q=n+2
        nod=node()
        nod.i=p
        nod.j=q
        if p >= 0 and q >= 0 and p < self.n and q < self.n :
            nod.h=self.heuristic(nod)
            nod.parent=e
            nod.move='LL'
            #print(nod.move,nod.h,"(",nod.i,",",nod.j,")")
            if nod.h <e.h :
                move.append(nod)


        p=m-2
        q=n
        nod=node()
        nod.i=p
        nod.j=q
        if p >= 0 and q >= 0 and p < self.n and q < self.n :
            nod.h=self.heuristic(nod)
            nod.parent=e
            nod.move='L'
            #print(nod.move,nod.h,"(",nod.i,",",nod.j,")")
            if nod.h <e.h :
                move.append(nod)
        #print(len(move),"--")
        return move

    def heuristic(self,n):
        n.i
        max_i=max(n.i,self.end.i)
        min_i=min(n.i,self.end.i)
        max_j=max(n.j,self.end.j)
        min_j=min(n.j,self.end.j)
        a=max_i - min_i
        b=max_j - min_j
        a=a*a
        b=b*b
        s=a+b
        return s

    def compare(self,a,b):
        if a.i==b.i and a.j==b.j :
            return True
        return False

    def removeseen(self,n):
        for i in range(len(n)):
            t=0
            for j in range(len(self.openx)):
                if self.compare(n[i],self.openx[j])==True :
                    del n[i]
                    t=1
                    break
            if t==1:
                break
        for i in range(len(n)):
            t=0
            for j in range(len(self.openx)):
                if self.compare(n[i],self.openx[j])==True :
                    del n[i]
                    t=1
                    break
            if t==1:
                break
        for i in range(len(n)):
            t=0
            for j in range(len(self.openx)):
                if self.compare(n[i],self.openx[j])==True :
                    del n[i]
                    t=1
                    break
            if t==1:
                break
            
        for i in range(len(n)):
            t=0
            for j in range(len(self.openx)):
                if self.compare(n[i],self.openx[j])==True :
                    del n[i]
                    t=1
                    break
            if t==1:
                break
        for i in range(len(n)):
            t=0
            for j in range(len(self.openx)):
                if self.compare(n[i],self.openx[j])==True :
                    del n[i]
                    t=1
                    break
            if t==1:
                break
        for i in range(len(n)):
            t=0
            for j in range(len(self.openx)):
                if self.compare(n[i],self.openx[j])==True :
                    del n[i]
                    t=1
                    break
            if t==1:
                break
        
        for i in range(len(n)):
            t=0
            for j in range(len(self.closex)):
                if self.compare(n[i],self.closex[j])==True :
                    del n[i]
                    t=1
                    break
            if t==1 :
                break

        for i in range(len(n)):
            t=0
            for j in range(len(self.closex)):
                if self.compare(n[i],self.closex[j])==True :
                    del n[i]
                    t=1
                    break
            if t==1 :
                break
        
        for i in range(len(n)):
            t=0
            for j in range(len(self.closex)):
                if self.compare(n[i],self.closex[j])==True :
                    del n[i]
                    t=1
                    break
            if t==1 :
                break
                
        for i in range(len(n)):
            t=0
            for j in range(len(self.closex)):
                if self.compare(n[i],self.closex[j])==True :
                    del n[i]
                    t=1
                    break
            if t==1 :
                break
        for i in range(len(n)):
            t=0
            for j in range(len(self.closex)):
                if self.compare(n[i],self.closex[j])==True :
                    del n[i]
                    t=1
                    break
            if t==1:
                break
        for i in range(len(n)):
            t=0
            for j in range(len(self.closex)):
                if self.compare(n[i],self.closex[j])==True :
                    del n[i]
                    t=1
                    break
            if t==1:
                break
        
        return n
        
    def printpath(self,x):
        a=[]
        a.append(x)
        par=x.parent
        while par != None:
            a.append(par)
            par=par.parent

        if self.paths[len(a)] == None :
            self.paths[len(a)]=a

    def solution(self):
        for i in range(100):
            if self.paths[i] != None :
                print (i-1)
                for j in range(len(self.paths[i])):
                    if self.paths[i][-1-j].move != None:
                        print (self.paths[i][-1-j].move,end=' ')
                return
        sol='Impossible'
        print (sol)
        return
    
def main():
    n=int(input())
    x=input()
    x=x.split()
    for i in range(len(x)):
        x[i]=int(x[i])
    s=node()
    e=node()
    s.i=x[1]
    s.j=x[0]
    e.i=x[3]
    e.j=x[2]
    find=redknight_chess(n,s,e)
    find.search()
    #print("done")
    find.solution()

if __name__ == '__main__':
    main()