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

import static java.lang.System.clearProperty;
import static java.lang.System.load;
import static java.lang.System.out;

public class Watermelon {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n=sc.nextInt();
        int xst=sc.nextInt(),yst=sc.nextInt(),xend=sc.nextInt(),yend=sc.nextInt();
        int[][] arr=new int[n][n];
        String[][] sarr=new String[n][n];
        for(int i=0;i<n;i++)
        {
            Arrays.fill(arr[i],Integer.MAX_VALUE);
            Arrays.fill(sarr[i],"");
        }
        recurs(arr,xst,yst,0,sarr,"");
        if(arr[xend][yend]!=Integer.MAX_VALUE)
            System.out.println(arr[xend][yend]+"\n"+sarr[xend][yend].substring(1,sarr[xend][yend].length()));
        else
            System.out.println("Impossible");
    }
    static void recurs(int[][] arr,int x,int y,int value,String[][] sarr,String s){
       // System.out.println("Heyt");
        try {
            if (value < arr[x][y]) {
                arr[x][y] = value;
                sarr[x][y]=s;
            }
            else return;
        }
        catch (Exception e) {
           // System.out.println("Exception");
            return;
        }
        //display(arr);
        //System.out.print("\n");
        recurs(arr,x-2,y-1,value+1,sarr,sarr[x][y]+" UL");
        recurs(arr,x-2,y+1,value+1,sarr,sarr[x][y]+" UR");
        recurs(arr,x,y+2,value+1,sarr,sarr[x][y]+" R");
        recurs(arr,x+2,y+1,value+1,sarr,sarr[x][y]+" LR");
        recurs(arr,x+2,y-1,value+1,sarr,sarr[x][y]+" LL");
        recurs(arr,x,y-2,value+1,sarr,sarr[x][y]+" L");
    }
    /** Function to update tree **/
    static void build(long[] tree,int[] arr,int node,int start,int end) {
        if (start == end) {
            tree[node] = arr[start];
            System.out.println("node "+node+" start " + start + " end " + end + " tree[node] " + tree[node]);
            return;
        }
        int mid = (start + end) >> 1;
        build(tree, arr,2 * node, start, mid);
        build(tree, arr,2 * node + 1, mid + 1, end);
        tree[node] = Math.min(tree[2 * node], tree[2 * node + 1]);
        //System.out.println(" start " + start + " end " + end + " tree[node]" + tree[node]);
    }
    private static  void update(long[] tree, int node,int pos, long val,int start,int end) {
        //System.out.println("start " + start + " end " + end);
        if (start == end) {
            tree[node] = val;
          //  System.out.println(tree[start]);
            return;
        } else {
            int mid = (start + end) >> 1;
            if (start <= pos && pos <= mid) {
                update(tree, 2 * node, pos, val, start, mid);
            } else {
                update(tree, 2 * node + 1, pos, val, mid + 1, end);
            }
            tree[node] = Math.min(tree[node * 2], tree[node * 2 + 1]);
        }

    }
    /** Function to query **/
    private static long query(long[] tree, int node, long l, long r, long start, long end) {
        if (start > r || end < l) return Integer.MAX_VALUE;
        if (start >= l && end <= r) {
            return tree[node];
        }
        long mid = (start + end) >> 1;
        long p1 = query(tree, node * 2, l, r, start, mid);
        long p2 = query(tree, node * 2 + 1, l, r, mid + 1, end);
       // System.out.println(" start " + start + " end " + end + " tree[node]" + tree[node]);
        return Math.min(p1,p2);
    }
    static void display(int[][] dp) {
        for(int i=0;i<dp.length;i++){
            for(int j=0;j<dp[i].length;j++){
                if(dp[i][j]==Integer.MAX_VALUE)
                    System.out.print("I\t");
                else
                     System.out.print(dp[i][j]+"\t");
            }
            System.out.println();
        }
    }
    static void display(String[][] dp) {
        for(int i=0;i<dp.length;i++){
            for(int j=0;j<dp[i].length;j++){
                    System.out.print(dp[i][j]+"\t\t\t");
            }
            System.out.println();
        }
    }
    static void display(int[] ans){
        for(int i=0;i<ans.length;i++)
            System.out.print(ans[i]+" ");
        System.out.println();

    }
    static void display(long[] ans,int n){
        for(int i=0;i<n;i++)
            System.out.print(ans[i]+" ");
        System.out.println();

    }
    static int gcd(int a, int b)
    {
        if (a == 0)
            return b;
        return gcd(b%a, a);
    }

    // Function to find gcd of array of
// numbers
    static int findGCD(Integer arr[], int n)
    {
        int result = arr[0];
        for (int i=1; i<n; i++)
            result = gcd(arr[i], result);
        return result;
    }
}
class Node implements Comparable{
    BigInteger[] arr=null;
    String[] srr=null;
    int index;
    static int key;
    static boolean lex=true,rev=true;
    Node(String[] str,int index){
        this.srr=str;
        arr=new BigInteger[srr.length];
        for(int i=0;i<srr.length;i++){
            arr[i]=new BigInteger(srr[i]);
        }
        this.index=index;
    }

    @Override public int compareTo (Object o) {
        Node n = (Node) o;
        if(!lex) {
                if (this.arr[key].compareTo(n.arr[key]) > 0) return 1;
                else if (this.arr[key].compareTo(n.arr[key]) < 0) return -1;
                else {
                    if(this.index<n.index) return -1;
                    else if(this.index>n.index)return 1;
                    else return 0;
                }
        }
        else{
                if (this.srr[key].compareTo(n.srr[key]) > 0) return 1;
                else if (this.srr[key].compareTo(n.srr[key]) < 0) return -1;
                else return 0;
            }
      }
}

class Path{
    int a,b,w;
    Path(int a,int b,int w){
        this.a=a;this.b=b;this.w=w;
    }
}