import java.io.*;
      import java.math.*;
      import java.security.KeyStore.Entry;
      import java.util.*;
         
                    
  class MyPro
         
		{
        	
        	private InputStream is;
        	private  PrintWriter out;
       
        	
        	public class node{
        		int x, y;
        		
        		public node(int a,int b)
        		{
        			x=a;
        			y=b;
        			
        			
        		}
        		
        		
        	}
        	
        	int n;
        	
        	String rs[][];
        	
        	void solve() throws IOException
        	{
        	    n=ni();
        		
        		rs=new String[n][n];
        		
        	    int sx=ni();
        	    
        	    int sy=ni();
        	    
        	    int dx=ni();
        	    
        	    int dy=ni();
        	    
        	    int x1[]={-2,-2,0,2,2,0};
        	    
        	    int y1[]={-1,1,2,1,-1,-2};
        	    
        	    String s[]={"UL","UR","R","LR","LL","L"};
        	    
        	    int x2[]={2,2,0,-2,-2,0};
        	    
        	    int y2[]={1,-1,-2,-1,1,2};
        	    
        	    HashMap<String,Integer> hm=new HashMap<>();
        	    
        	    for(int i=0;i<6;i++)
        	    {
        	    	hm.put(s[i],i);
        	    
        	    }
        	    
        	    
        	    
        	    ArrayList<node> q=new ArrayList<>();
        	    
        	    q.add(new node(sx,sy));
        	    
        	    while(!q.isEmpty())
        	    {
        	    	
        	    	ArrayList<node> tmp=new ArrayList<>();
        	    
		        	    while(!q.isEmpty())
		        	    {
		        	    	node z=q.remove(0);
		        	    	
		        	    	for(int i=0;i<6;i++)
		        	    	{
		        	    		int xx=z.x+x1[i];
		        	    		
		        	    		int yy=z.y+y1[i];
		        	    		
		        	    		if(is_safe(xx,yy))
		        	    		{
		        	    			
		        	    			tmp.add(new node(xx,yy));
		        	    			rs[xx][yy]=s[i];
		        	    			
		        	    			
		        	    		}
		        	    		
		        	    	}
		        	    	
		        	    	if(rs[dx][dy]!=null)
		        	    		break;
		        	    	
		        	    	
		        	    }
		        	    
		        	    if(rs[dx][dy]!=null)
	        	    		break;
	        	    	
		        	    q=tmp;
		        	    
		            
        	    
        	     }
        	    
        	    
        	    if(rs[dx][dy]==null)
        	    {
        	    		out.println("Impossible");
        	    	
        	    }
        	    else
        	    {	
		        	    int dis=0;
		        	    
		        	    String path="";
		        	    
		        	    while(true)
		        	    {
		        	    	String w=rs[dx][dy];
		        	    	
		        	    	path=w+" "+path;
		        	    	
		        	    	int r=hm.get(w);
		        	    	
		        	    	dx=dx+x2[r];
		        	    	
		        	    	dy=dy+y2[r];
		        	    	
		        	    	dis++;
		        	    	
		        	    	if(dx==sx&&dy==sy)
		        	    		break;
		        	    	
		        	    }
		        	    
		        	    out.println(dis);
		        	    
		        	    out.println(path);
		        	    
        	    }
        	        	    
        		
        	   }


			private boolean is_safe(int i, int j) {
				
				if(i>=0&&j>=0&&i<n&&j<n)
				{
					if(rs[i][j]==null)
						return true;
					
				}
				
				
				return false;
			}


			void run() throws Exception {
            		is = System.in;
            		out = new PrintWriter(System.out);
            		solve();
            		out.flush();
            	
        	}
             
            public static void main(String[] args) throws Exception {
            		new Thread(null, new Runnable() {
            			public void run() {
            				try {
            					new MyPro().run();
            				} catch (Exception e) {
            					e.printStackTrace();
            				}
            			}
            		}, "1", 1 << 26).start();
	}
 
	// To Get Input
	// Some Buffer Methods
	private byte[] inbuf = new byte[1024];
	public int lenbuf = 0, ptrbuf = 0;
	
	private int readByte() {
		if (lenbuf == -1)
			throw new InputMismatchException();
		if (ptrbuf >= lenbuf) {
			ptrbuf = 0;
			try {
				lenbuf = is.read(inbuf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			if (lenbuf <= 0)
				return -1;
		}
		return inbuf[ptrbuf++];
	}
 
	private boolean isSpaceChar(int c) {
		return !(c >= 33 && c <= 126);
	}
 
	private int skip() {
		int b;
		while ((b = readByte()) != -1 && isSpaceChar(b))
			;
		return b;
	}
 
	private double nd() {
		return Double.parseDouble(ns());
	}
 
	private char nc() {
		return (char) skip();
	}
 
	private String ns() {
		int b = skip();
		StringBuilder sb = new StringBuilder();
		while (!(isSpaceChar(b))) { // when nextLine, (isSpaceChar(b) && b != '
									// ')
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}
 
	private char[] ns(int n) {
		char[] buf = new char[n];
		int b = skip(), p = 0;
		while (p < n && !(isSpaceChar(b))) {
			buf[p++] = (char) b;
			b = readByte();
		}
		return n == p ? buf : Arrays.copyOf(buf, p);
	}
 

 
	private int[] na(int n) {
		int[] a = new int[n];
		
		for (int i = 0; i < n; i++)
			{
			  a[i] = ni();
			  
			  
			}
		
		
		return a;
	}
 
	private void pa(int[] a) {
		int i=0;
		
	   while(i<a.length)
	   {
		   System.out.print(a[i++]+" ");
	   }
		
		
		
		
	}
	
	
	private int ni() {
		int num = 0, b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-') {
			minus = true;
			b = readByte();
		}
 
		while (true) {
			if (b >= '0' && b <= '9') {
				num = num * 10 + (b - '0');
			} else {
				return minus ? -num : num;
			}
			b = readByte();
		}
	}
 
	private long nl() {
		long num = 0;
		int b;
		boolean minus = false;
		while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
			;
		if (b == '-') {
			minus = true;
			b = readByte();
		}
 
		while (true) {
			if (b >= '0' && b <= '9') {
				num = num * 10 + (b - '0');
    			} else {
    				return minus ? -num : num;
    			}
    			b = readByte();
    		}
    	}
    	
   }