import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Practice {

	private static InputStream stream;
	private static byte[] buf = new byte[1024];
	private static int curChar;
	private static int numChars;
	private static SpaceCharFilter filter;
	private static PrintWriter pw;
    public static void main(String[] args) {
    	InputReader(System.in);
		pw = new PrintWriter(System.out); 
        new Thread(null ,new Runnable(){
           public void run(){
               try{
                   solve();//This is solution method
           pw.close();
       } catch(Exception e){
           e.printStackTrace();
       }
   }
},"1",1<<26).start();
        }
    
    static int st[];
    private static void solve(){
    
    	int n=nextInt();
    	int s_x=nextInt();
    	int s_y=nextInt();
    	int d_x=nextInt();
    	int d_y=nextInt();
    	HashMap<Integer,String> hm=new HashMap<Integer,String>();
    	hm.put(1, "UL");
    	hm.put(2, "UR");
    	hm.put(3, "R");
    	hm.put(4, "LR");
    	hm.put(5, "LL");
    	hm.put(6, "L");
    	Queue<Pair> q=new LinkedList<Pair>();
    	q.add(new Pair(s_x,s_y));
    	long moves[][]=new long[n][n];
    	Pair backtrack[][]=new Pair[n][n];
    	int dir[][]=new int[n][n];
    	boolean Visited[][]=new boolean[n][n]; 
    	for(int i=0;i<n;i++){
    		Arrays.fill(moves[i], Integer.MAX_VALUE);
    	}
    	moves[s_x][s_y]=0;
    	while(!q.isEmpty()){
    		Pair top=q.poll();
    		int x=top.x;
    		int y=top.y;
    		if(check(x-2, y-1, n) && !Visited[x-2][y-1]){
    			backtrack[x-2][y-1] = new Pair(x, y);
    			dir[x-2][y-1] = 1;
    			moves[x-2][y-1] = moves[x][y]+1;
    			Visited[x-2][y-1]=true;
    			q.add(new Pair(x-2, y-1));
    		}
    		if(check(x-2, y+1, n) && !Visited[x-2][y+1]){
    			backtrack[x-2][y+1] = new Pair(x, y);
    			dir[x-2][y+1] = 2;
    			moves[x-2][y+1] = moves[x][y]+1;
    			Visited[x-2][y+1]=true;

    			q.add(new Pair(x-2, y+1));
    		}
    		if(check(x, y+2, n) && !Visited[x][y+2]){
    			backtrack[x][y+2] = new Pair(x, y);
    			dir[x][y+2] = 3;
    			moves[x][y+2] = moves[x][y]+1;
    			Visited[x][y+2]=true;

    			q.add(new Pair(x, y+2));
    		}
    		if(check(x+2, y+1, n) && !Visited[x+2][y+1]){
    			backtrack[x+2][y+1] = new Pair(x, y);
    			dir[x+2][y+1] = 4;
    			moves[x+2][y+1] = moves[x][y]+1;
    			Visited[x+2][y+1]=true;

    			q.add(new Pair(x+2, y+1));
    			}
    		if(check(x+2, y-1, n) && !Visited[x+2][y-1]){
    			backtrack[x+2][y-1] = new Pair(x, y);
    			dir[x+2][y-1] = 5;
    			moves[x+2][y-1] = moves[x][y]+1;
    			Visited[x+2][y-1]=true;

    			q.add(new Pair(x+2, y-1));
    		}
    		if(check(x, y-2, n) && !Visited[x][y-2]){
    			backtrack[x][y-2] = new Pair(x, y);
    			dir[x][y-2] = 6;
    			moves[x][y-2] = moves[x][y]+1;
    			Visited[x][y-2]=true;

    			q.add(new Pair(x, y-2));
    		}
    		
    	}
    	if(moves[d_x][d_y]==Integer.MAX_VALUE){
    		pw.println("Impossible");
    	}else{
    		pw.println(moves[d_x][d_y]);
    		Stack<String> st=new Stack<String>();
    		
    		while(d_x!=s_x || d_y!=s_y){
    			//pw.println(d_x+" "+d_y);
    			Pair get = backtrack[d_x][d_y];
    			st.push(hm.get(dir[d_x][d_y]));
    			d_x=get.x;
    			d_y=get.y;
    			
    			
    		}
    		while(!st.isEmpty()){
    			pw.print(st.pop()+" ");
    		}
    	}
    	
    	
    			
    	
       }
    public static boolean check(int x,int y,int n){
    	if(x>=0 && x<n && y>=0 && y<n)
    		return true;
    	return false;
    }
   
private static void update(int node,int low,int high,int ind,int val){
    	 if(ind < low || ind > high){
             return;
         }
		
		if(low==high){
     		st[node]=val;
     		return;
    	 }
    	 
    	int mid=(low+high)/2;
    	if(low<= ind && ind<=mid){
    		update(2*node, low, mid, ind, val);
    	}else{
    		update(2*node+1, mid+1, high, ind, val);
    	}
     st[node]= st[2*node] + st[2*node+1];
}
    
private static int query(int node,int low,int high,int qlow,int qhigh){
    	
    	if(qlow>high || qhigh<low){
    		return 0;
    	}
    	 
    	if(qlow<=low && qhigh>=high){
        	
    		return st[node];
    	}
    	
    int mid=(low+high)/2;
    int ans1=query(2*node, low, mid, qlow, qhigh);
    int ans2=query(2*node+1, mid+1, high, qlow, qhigh);
    
    return ans1 + ans2;
    }
    
    

 // To Get Input
 // Some Buffer Methods
  
     		     	
     		    	public static void InputReader(InputStream stream1) {
     		    		stream = stream1;
     		    	}
  
     		    	private static boolean isWhitespace(int c) {
     		    		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
     		    	}
  
     		    	private static boolean isEndOfLine(int c) {
     		    		return c == '\n' || c == '\r' || c == -1;
     		    	}
  
     		    	private static int read() {
     		    		if (numChars == -1)
     		    			throw new InputMismatchException();
     		    		if (curChar >= numChars) {
     		    			curChar = 0;
     		    			try {
     		    				numChars = stream.read(buf);
     		    			} catch (IOException e) {
     		    				throw new InputMismatchException();
     		    			}
     		    			if (numChars <= 0)
     		    				return -1;
     		    		}
     		    		return buf[curChar++];
     		    	}
  
     		    	private static int nextInt() {
     		    		int c = read();
     		    		while (isSpaceChar(c))
     		    			c = read();
     		    		int sgn = 1;
     		    		if (c == '-') {
 							sgn = -1;
 							c = read();
						}	
						int res = 0;
						do {
 							if (c < '0' || c > '9')
 								throw new InputMismatchException();
							res *= 10;
							res += c - '0';
     		    			c = read();
     		    		} while (!isSpaceChar(c));
     		    		return res * sgn;
     		    	}
  
     		    	private static long nextLong() {
     		    		int c = read();
     		    		while (isSpaceChar(c))
     		    			c = read();
     		    		int sgn = 1;
     		    		if (c == '-') {
 							sgn = -1;
 							c = read();
						}
						long res = 0;
						do {
							if (c < '0' || c > '9')
 								throw new InputMismatchException();
							res *= 10;
						    res += c - '0';
     		    			c = read();
     		    		} while (!isSpaceChar(c));
     		    		return res * sgn;
     		    	}
  
     		    	private static String nextToken() {
     		    		int c = read();
     		    		while (isSpaceChar(c))
     		    			c = read();
     		    		StringBuilder res = new StringBuilder();
     		    		do {
     		    			res.appendCodePoint(c);
     		    			c = read();
     		    		} while (!isSpaceChar(c));
     		    		return res.toString();
     		    	}
  
     		    	private static String nextLine() {
     		    		int c = read();
     		    		while (isSpaceChar(c))
     		    			c = read();
     		    		StringBuilder res = new StringBuilder();
     		    		do {
     		    			res.appendCodePoint(c);
     		    			c = read();
     		    		} while (!isEndOfLine(c));
     		    		return res.toString();
     		    	}
  
     		    	private static int[] nextIntArray(int n) {
     		    		int[] arr = new int[n];
     		    		for (int i = 0; i < n; i++) {
     		    			arr[i] = nextInt();
     		    		}
     		    		return arr;
     		    	}
  
     		    	private static long[][] next2dArray(int n, int m) {
     		    		long[][] arr = new long[n][m];
     		    		for (int i = 0; i < n; i++) {
     		    			for (int j = 0; j < m; j++) {
     		    				arr[i][j] = nextLong();
     		    			}
     		    		}
     		    		return arr;
     		    	}
     		    	private static char[][] nextCharArray(int n,int m){
     		    		char [][]c=new char[n][m];
     		    		for(int i=0;i<n;i++){
     		    			String s=nextLine();
     		    			for(int j=0;j<s.length();j++){
     		    				c[i][j]=s.charAt(j);
     		    			}
     		    		}
     		    		return c;
     		    	}
  
     		    	private static long[] nextLongArray(int n) {
     		    		long[] arr = new long[n];
     		    		for (int i = 0; i < n; i++) {
     		    			arr[i] = nextLong();
     		    		}
     		    		return arr;
     		    	}
  
     		    	private static void pArray(int[] arr) {
     		    		for (int i = 0; i < arr.length; i++) {
     		    			pw.print(arr[i] + " ");
     		    		}
     		    		pw.println();
     		    		return;
     		    	}
  
     		    	private static void pArray(long[] arr) {
     		    		for (int i = 0; i < arr.length; i++) {
     		    			pw.print(arr[i] + " ");
     		    		}
     		    		pw.println();
     		    		return;
     		    	}
  
     		    	private static void pArray(boolean[] arr) {
     		    		for (int i = 0; i < arr.length; i++) {
     		    			pw.print(arr[i] + " ");
     		    		}
     		    		pw.println();
     		    		return;
     		    	}
  
     		    	private static boolean isSpaceChar(int c) {
     		    		if (filter != null)
     		    			return filter.isSpaceChar(c);
     		    		return isWhitespace(c);
     		    	}
  
     		    	private interface SpaceCharFilter {
     		    		public boolean isSpaceChar(int ch);
     		    	}
    
}

class Pair implements Comparable<Pair>{
int x,y;

public Pair(int x,int y) {

	this.x=x;
	this.y=y;
}

@Override
public int compareTo(Pair arg0) {
	// TODO Auto-generated method stub
	return 0;
}
}