#!/bin/python3

import sys

# Priority queue with manhattan distance
import copy

# at the end of the queue are the best elements
def queue_push(q, element, target):
    if element in q:
        return q
    if len(q) == 0:
        q.append(element)
    else:
        for i, e in enumerate(q):
            if element[1] > e[1]:
                q.insert(i, element)
                break
            if i == (len(q)-1):
                q.append(element)
                break
    return q

def get_next_moves(pos, grid_size): 
    next_moves = []
    steps = pos[1] + 1
    position = pos[0]
    
    if position[1] - 2 >= 0:
        if position[0] - 1 >= 0:
            t = copy.copy(pos[2])
            t.append("UL")
            tmp = ((position[0] - 1, position[1] - 2), steps, t) # UL
            next_moves.append(tmp)
        if position[0] + 1 < grid_size:
            t = copy.copy(pos[2])
            t.append("UR")
            tmp = ((position[0] + 1, position[1] - 2), steps, t) # UR
            next_moves.append(tmp)
            
    if position[0] + 2 < grid_size:
        t = copy.copy(pos[2])
        t.append("R")
        tmp = ((position[0] + 2, position[1]), steps, t) # R
        next_moves.append(tmp)

    if position[1] + 2 < grid_size:
        if position[0] + 1 < grid_size:
            t = copy.copy(pos[2])
            t.append("LR")
            tmp = ((position[0] + 1, position[1] + 2), steps, t) # LR
            next_moves.append(tmp)
        if position[0] - 1 >= 0:
            t = copy.copy(pos[2])
            t.append("LL")
            tmp = ((position[0] - 1, position[1] + 2), steps, t) # LL
            next_moves.append(tmp)
        
    if position[0] - 2 >= 0:
        t = copy.copy(pos[2])
        t.append("L")
        tmp = ((position[0] - 2, position[1]), steps, t) # L
        next_moves.append(tmp)

    return next_moves

def printShortestPath(n, i_start, j_start, i_end, j_end):
    target = (j_end, i_end)
    start = ((j_start, i_start), 0, [])
    queue = [start]
    searched = set()
    length = None
    path = None
    while len(queue) > 0:

        node = queue.pop()
        if node[0] in searched:
            continue
     
        if node[0] == target:
            length = node[1]
            path = node[2]
            break
        
        searched.add(node[0])
        for next_node in get_next_moves(node, n):
            queue = queue_push(queue, next_node, target)
    if length == None:
        print("Impossible")
    else:
        print(length)
        print(" ".join(path))

if __name__ == "__main__":
    n = int(input().strip())
    i_start, j_start, i_end, j_end = input().strip().split(' ')
    i_start, j_start, i_end, j_end = [int(i_start), int(j_start), int(i_end), int(j_end)]
    printShortestPath(n, i_start, j_start, i_end, j_end)