import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {
    
    static int[][] dir = new int[][]{{-2, -1},{-2, 1},{0, 2},{2, 1},{2, -1},{0, -2}};
    static String[] moves = new String[]{"UL", "UR", "R", "LR", "LL", "L"};
    
    static class Node{
        Node pre;
        String type;
        int dist;
        int x;
        int y;
        Node(int i, int j, int d, String t){
            x = i;
            y = j;
            type = t;
            dist = d;
            pre = null;
        }
    }
    
    static void printShortestPath(int n, int i_start, int j_start, int i_end, int j_end) {
        //  Print the distance along with the sequence of moves.
        List<Integer> list = new ArrayList<>();
        HashSet<List<Integer>> set = new HashSet<>();
        int dist = Math.abs(i_start - i_end) + Math.abs(j_start - j_end);
        Queue<Node> queue= new LinkedList<>();
        queue.offer(new Node(i_start, j_start, dist, "O"));
        set.add(Arrays.asList(i_start, j_start));    
        while(!queue.isEmpty()) {
            for(int q = 0; q < queue.size(); q++) {
                Node curNode = queue.poll();
                int cur_i = curNode.x, cur_j = curNode.y;
                for(int i = 0; i < 6; i++) {
                    int new_i = cur_i + dir[i][0], new_j = cur_j + dir[i][1];
                    int new_dist = Math.abs(new_i - i_end) + Math.abs(new_j - j_end);
                    if(new_dist < curNode.dist) {
                        if(!set.add(Arrays.asList(new_i, new_j))) {
                            continue;
                        }
                        Node newNode = new Node(new_i, new_j, new_dist, moves[i]);
                        newNode.pre = curNode;
                        if(new_dist == 0) {
                            traceBack(newNode);
                            return;
                        }
                        queue.offer(newNode);
                    }
                }
            }
        }
        System.out.println("Impossible");
    }

    
    static void traceBack(Node node) {
        List<String> ret = new LinkedList<>();
        while(!node.type.equals("O")) {
        //while(node != null) {
            //System.out.println(node.type + " " + node.dist + " " + node.x + " " + node.y);
            ret.add(0, node.type);
            node = node.pre;
        }
        //System.out.println(ret);
        System.out.println(ret.size());
        int idx = 0;
        for(String s : ret) {
            if(idx != 0) {
                System.out.print(" ");
            }
            System.out.print(s);
            idx++;    
        }
    }
    
    /*
    static void printShortestPath(int n, int i_start, int j_start, int i_end, int j_end) {
        //  Print the distance along with the sequence of moves.
        List<Integer> list = new ArrayList<>();
        int dist = Math.abs(i_start - i_end) + Math.abs(j_start - j_end);
        int pre_dist = dist + 1;
        HashSet<List<Integer>> set = new HashSet<>();
        set.add(Arrays.asList(Math.abs(i_start - i_end), Math.abs(j_start - j_end)));
        while(dist > 0) {
            pre_dist = dist;
            int min = Integer.MAX_VALUE;
            int idx = 0;
            for(int i = 0; i < 6; i++) {
                int new_i = i_start + dir[i][0], new_j = j_start + dir[i][1];
                if(new_i < 0 || new_i >= n || new_j < 0 || new_j >= n) {
                    continue;
                }
                int new_dist = Math.abs(new_i - i_end) + Math.abs(new_j - j_end);
                if(new_dist < min) {
                    idx = i;
                    min = new_dist;
                }
            }
            i_start += dir[idx][0];
            j_start += dir[idx][1];
            if(!set.add(Arrays.asList(Math.abs(i_start - i_end), Math.abs(j_start - j_end)))) {
                System.out.print("Impossible");
                return;
            }
            dist = min;
            list.add(idx);
        }
        if(dist != 0) {
            System.out.print("Impossible");
        } else {
            System.out.println(list.size());
            for(int i = 0; i < list.size(); i++) {
                if(i != 0) {
                    System.out.print(" ");
                }
                System.out.print(moves[list.get(i)]);
            }
        }
            
    
        
    }
    */
    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int i_start = in.nextInt();
        int j_start = in.nextInt();
        int i_end = in.nextInt();
        int j_end = in.nextInt();
        printShortestPath(n, i_start, j_start, i_end, j_end);
        in.close();
    }
}