import java.util.*;
import java.io.*;

public class Solution {
	private static boolean[][] visited;
	private static int[][] level;
	static int[][] par;
	
	static int[] fx = {-2,-2,0,2,2,0};
	static int[] fy = {-1,1,2,1,-1,-2};
	
	public static boolean checkBoundary(int i,int j, int n) {
		return i>=0 && i<n && j>=0 && j<n;
	}
	
	static class Node {
		int x;
		int y;
		Node next;
		
		Node(int x, int y) {
			this.x = x;
			this.y = y;
			this.next = null;
		}
	}
	
	private static void bfs(int x, int y, int n) {
		//System.out.println("r " + x+ " " + y + " " +n);
		level[x][y] = 0;
		//visited[x][y] = true;
		
		Node srcNode = new Node(x,y);
		Node queue = srcNode;
		Node temp = queue;
		
		while(queue!=null) {
			int nowX = queue.x;
			int nowY = queue.y;

			//System.out.println("t " + nowX + " " +nowY + " " + level[nowX][nowY]);
			
			for(int i=0;i<6;i++) {
				int tx=nowX+fx[i];
				int ty=nowY+fy[i];
				
				if(checkBoundary(tx,ty,n) && !visited[tx][ty]) {
					visited[tx][ty] = true;
					level[tx][ty] = level[nowX][nowY]+1;
					par[tx][ty] = i;
					//System.out.println("t " + tx + " " +ty + " " + level[tx][ty]);
					temp.next = new Node(tx,ty);
					temp = temp.next;
				}
			}
			queue = queue.next;
		}
	
	} 
	
	static void resultPrint(int x, int y, int iStart, int jStart) {
		if(x==iStart && y==jStart) {
			return;
		}
		int t = par[x][y];
		resultPrint(x-fx[t],y-fy[t],iStart,jStart);
		switch (t) {
			case 0:
				System.out.print("UL ");
				break;
			case 1:
				System.out.print("UR ");
				break;
			case 2:
				System.out.print("R ");
				break;
			case 3:
				System.out.print("LR ");
				break;
			case 4:
				System.out.print("LL ");
				break;
			case 5:
				System.out.print("L ");
				break;
			default:
				break;
		}
	}
	
	public static void main(String[] args) throws Exception{
		InputReader in = new InputReader(System.in);
		
		int n = in.nextInt();
		visited = new boolean[n][n];
		level = new int[n][n];
		par = new int[n][n];

		int iStart = in.nextInt();
		int jStart = in.nextInt();
		int iEnd = in.nextInt();
		int jEnd = in.nextInt();
		
		bfs(iStart,jStart,n);
		if(iStart==iEnd && jStart==jEnd) {
			System.out.println(0);
		} else if(level[iEnd][jEnd]==0) {
			System.out.println("Impossible");
		} else {
			System.out.println(level[iEnd][jEnd]);
			resultPrint(iEnd,jEnd,iStart,jStart);
			System.out.println();
		}
		
	}
	
	public static void QuickSort(int[] A, int lo, int hi) {
		if(lo<hi) {
			int index = partition(A,lo, hi);
			QuickSort(A, lo, index-1);
			QuickSort(A, index+1, hi);
		}
	}
	
	public static int partition(int[] A, int lo, int hi) {
		int pivot = A[hi];
		
		int i = lo-1;
		
		for(int j=lo;j<hi;j++) {
			if(A[j]<=pivot) {
				i++;
				swap(A,i,j);
			}
		}
		swap(A,i+1,hi);
		return i+1;
	}
	
	public static void swap(int[] A, int i, int j) {
		int temp = A[i];
		A[i] = A[j];
		A[j] = temp;
	}
	
	//Search for A particular Key in a sorted array
	public static int binarySearch(int[] A, int key, int lo, int hi) {
		while(lo<=hi) {
			int mid = (lo+hi)/2;
			if(A[mid]==key) {
				return mid;
			} else if(A[mid]>key) {
				hi = mid-1;
			} else {
				lo = mid+1;
			}
		}
		return -1;
	}
	
	public static int upperBound(int[] A, int key, int lo, int hi) {
		while(lo<=hi) {
			int mid = (lo+hi)/2;
			if(A[mid]>key && (mid==1 || A[mid-1]<=key)) {
				return mid;
			} else if(A[mid]>key) {
				hi = mid-1;
			} else {
				lo = mid+1;
			}
		}
		return -1;
	}
	
	public static int lowerBound(int[] A, int key, int lo, int hi) {
		while(lo<=hi) {
			int mid = (lo+hi)/2;
			if(A[mid]>=key && (mid==1 || A[mid-1]<key)) {
				return mid;
			} else if(A[mid]>=key) {
				hi = mid-1;
			} else {
				lo = mid+1;
			}
		}
		return -1;
	}
	
	public static int power(int x, int n) {
		if(n==0) {
			return 1;
		}
		if(n==1) {
			return x;
		}
		int ret = power(x,n/2);
		int val = ret*ret;
		if(n%2==1) {
			val*=x;
		}
		return val;
	}
	
	public static void initialize(int[] A, int[] segmentTree, int start, int end, int index) {
		if(start==end) {
			segmentTree[index] = start;
			return;
		}
		
		int mid = (start+end)/2;
		
		initialize(A,segmentTree, start, mid, index*2+1);
		initialize(A,segmentTree, mid+1, end, index*2+2);
		
		if(A[segmentTree[index*2+1]]<=A[segmentTree[index*2+2]]) {
			segmentTree[index] = segmentTree[index*2+1];
		} else {
			segmentTree[index] = segmentTree[index*2+2];
		}
	}
	
	public static void update(int[] A, int[] segmentTree, int start, int end, int index, int pos, int val) {
		if(start==end) {
			A[segmentTree[index]] = val;
			return;
		}
		
		int mid = (start+end)/2;
		
		if(pos<=mid) {
			update(A,segmentTree,start,mid,index*2+1,pos,val);
		} else {
			update(A,segmentTree,mid+1,end,index*2+2,pos,val);
		}
		
		if(A[segmentTree[index*2+1]]<=A[segmentTree[index*2+2]]) {
			segmentTree[index] = segmentTree[index*2+1];
		} else {
			segmentTree[index] = segmentTree[index*2+2];
		}
	}
	
	public static int query(int[] A, int[] segmentTree, int start, int end, int index, int rangeStart, int rangeEnd) {
		if(rangeStart>end || rangeEnd<start) {
			return -1;
		}
		if(rangeStart<=start && rangeEnd>=end) {
			return segmentTree[index];
		}
		
		int mid = (start+end)/2;
		int val1 = query(A,segmentTree, start, mid, index*2+1, rangeStart, rangeEnd);
		int val2 = query(A,segmentTree, mid+1, end, index*2+2, rangeStart, rangeEnd);
		
		if(val1==-1) {
			return val2;
		} 
		if(val2==-1) {
			return val1;
		}
		if(A[val1]<=A[val2]) {
			return val1;
		}
		return val2;
	}
	
	public static void constructSegmentTree(int[] A, int n) {
		int x = (int)Math.ceil(Math.log(n)/Math.log(2));
		
		int size = (int)Math.pow(2,x+1)-1;
		
		int[] segmentTree = new int[size+1];
		initialize(A,segmentTree,0,n-1,0);
		//update
		update(A,segmentTree,0,n-1,0,4,10);
		
		//query
		int ret = query(A,segmentTree,0,n-1,0,9,9);
	}
	
	//Z Algorithm
	public static int[] createLCPArray(String str) {
		int len = str.length();
		int[] lcp = new int[len];
		int L=0,R=0;
		lcp[0] = 0;
		
		for(int i=1;i<len;i++) {
			if(i>R) {
				L=R=i;
				while(R<len && str.charAt(R)==str.charAt(R-L)) {
					R++;
				}
				lcp[i] = R-L;
				R--;
			} else {
				int k = i-L;
				if(lcp[k]<R-i+1) {
					lcp[i] = lcp[k];
				} else {
					L=i;
					R++;
					while(R<len && str.charAt(R)==str.charAt(R-L)) {
						R++;
					}
					lcp[i] = R-L;
					R--;
				}
				
			}
		}
		
		return lcp;
	}
	
	public static int[][][] FibonacciGeneration(int P) {
		int[][][] A = new int[P][2][2];
		A[0][0][0] = 1;
		A[0][0][1] = 1;
		A[0][1][0] = 1;
		A[0][1][1] = 0;
		
		for(int i=1;i<P;i++) {
			A[i][0][0] = A[i-1][0][0]*A[i-1][0][0] + A[i-1][0][1]*A[i-1][1][0];
			A[i][0][1] = A[i-1][0][0]*A[i-1][0][1] + A[i-1][0][1]*A[i-1][1][1];
			A[i][1][0] = A[i-1][1][0]*A[i-1][0][0] + A[i-1][1][1]*A[i-1][1][0];
			A[i][1][1] = A[i-1][1][0]*A[i-1][0][1] + A[i-1][1][1]*A[i-1][1][1];
		}
		return A;
	}
	
	public static int[][] matrixMultiplication(int[][] A, int[][] B) {
		int ARow = A.length;
		int ACol = A[0].length;

		int BCol = B[0].length;
		
		int[][] C = new int[ARow][BCol];
		
		for(int i=0;i<ARow;i++) {
			for(int j=0;j<BCol;j++) {
				C[i][j]=0;
				for(int k=0;k<ACol;k++) {
					C[i][j] += A[i][k]*B[k][j];
				}
			}
		}
		return C;
	}
	
	
	public static void Fibonacci() {
		//Array Size
		int N = 1000000001;
		//highest 2 power which is less than N
		int P = (int)Math.ceil(Math.log(N)/Math.log(2));
		//A contains fibonacci matrix for the power of 2's
		int[][][] A = FibonacciGeneration(P);
		
		//Lth Fibonacci(T=L-1)
		int T = 6;
		int[][] rs = {{1,0},{0,1}};
		
		for(int i=P-1;i>=0;i--) {
			if((T&(1<<i))!=0) {
				rs = matrixMultiplication(rs,A[i]);
			}
		}
		
		int rslt = rs[0][0] + rs[0][1];
	}
	
	static class InputReader {
		public BufferedReader reader;
		public StringTokenizer tokenizer;
		
		public InputReader(InputStream stream) {
			reader = new BufferedReader(new InputStreamReader(stream));
			tokenizer = null;
		}
		
		public String next() throws Exception {
			while(tokenizer==null || !tokenizer.hasMoreTokens()) {
				tokenizer = new StringTokenizer(reader.readLine());
			}
			return tokenizer.nextToken();
		}
		
		public String nextLine() throws Exception {
			return reader.readLine();
		}
		
		public int nextInt() throws Exception {
			return Integer.parseInt(next());
		}
		
		public long nextLong() throws Exception {
			return Long.parseLong(next());
		}
		
		public double nextDouble() throws Exception {
			return Double.parseDouble(next());
		}
	}
}