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

public class Solution {

    private static class Point implements Comparable<Point> {
		int i;
		int j;
		int move;
		int dist;
		Point(int i, int j, int m, int dist) {
			this.i = i;
			this.j = j;
			move = m;
			this.dist = dist;
		}
		public int compareTo(Point p) {
			if(this.dist != p.dist)
				return this.dist - p.dist;
			return this.move - p.move;
		}
	}
	private static String[] moveCodes = {"UL", "UR", "R", "LR", "LL", "L"};
	private static int[][] distTo;
	private static Point[][] pointFrom;
	private static Queue<Point> pathPriorityQueue;
    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.
    	distTo = new int[n][n];
    	for(int i = 0; i < n; i++)
    		Arrays.fill(distTo[i], Integer.MAX_VALUE);
    	distTo[i_start][j_start] = 0;
    	pathPriorityQueue = new PriorityQueue<>();
    	pointFrom = new Point[n][n];
    	pathPriorityQueue.add(new Point(i_start, j_start, -1, 0));
        while (!pathPriorityQueue.isEmpty() && !(distTo[i_end][j_end] < Integer.MAX_VALUE)) {
        	Point p = pathPriorityQueue.remove();
            relax(p, n);
        }
        if((distTo[i_end][j_end] < Integer.MAX_VALUE)) {
        	Deque<String> path = new ArrayDeque<>();
        	Point p = pointFrom[i_end][j_end];
        	while(p.i != i_start && p.j != j_start) {
        		path.push(moveCodes[p.move]);
        		p = pointFrom[p.i][p.j];
        	}
        	path.push(moveCodes[p.move]);
        	System.out.println(path.size());
        	while(!path.isEmpty()) {
        		System.out.print(path.pop());
        		if(!path.isEmpty())
					System.out.print(" ");
        	}
        }
        else
        	System.out.println("Impossible");
    }
    
    private static void relax(Point p, int n) {
        int[] dy = {-1, 1, 2, 1, -1, -2};
        int[] dx = {-2, -2, 0, 2, 2, 0};
        for(int k = 0; k < 6; k++) {
        	int new_i = p.i + dx[k];
        	int new_j = p.j + dy[k];
        	if(new_i >= 0 && new_j >= 0 &&
        		new_i < n && new_j < n)
        
	        if (distTo[new_i][new_j] > distTo[p.i][p.j] + 1) {
	            distTo[new_i][new_j] = distTo[p.i][p.j] + 1;
	            pointFrom[new_i][new_j] = new Point(p.i, p.j, k, distTo[new_i][new_j]);
	            pathPriorityQueue.add(new Point(new_i, new_j, k, distTo[new_i][new_j]));
	        }
        }
    }

    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();
    }
}