//>>>BaZ<<<//
import java.util.*;
import java.io.*;
import static java.lang.Math.*;
public class Main
{    
    //UL, UR, R, LR, LL, L
    static int dx[] = {-2,-2,0,2,2,0};
    static int dy[] = {-1,1,2,1,-1,-2};
    static String type[] = {"UL","UR","R","LR","LL","L"};
    static long MOD = 1000000007;
    static int INF = Integer.MAX_VALUE/10;
    static PrintWriter pw;
    static Reader scan;
    //static MyFileReader scan;
    //static MyFileReader1 ss;
    static int ni() throws IOException{return scan.nextInt();}
    static long nl() throws IOException{return scan.nextLong();}
    static double nd() throws IOException{return scan.nextDouble();}
    static void pl() throws IOException{pw.println();}
    static void pl(Object o) throws IOException{pw.println(o);}
    static void p(Object o) throws IOException {pw.print(o+" ");}
    static void psb(StringBuilder sb) throws IOException {pw.print(sb);}
    public static void main(String[] args){
        new Thread(null,null,"BaZ",99999999)
        {
            public void run()
            {
                try
                {
                    solve();
                }
                catch(Exception e)
                {  
                    e.printStackTrace();
                    System.exit(1);
                }
            }
        }.start();
    }
    static void solve() throws IOException
    {  
        Calendar CAL1 = Calendar.getInstance();
        CAL1.setTime(new Date());
        scan = new Reader();
        //scan = new MyFileReader();
        //ss = new MyFileReader1();
        pw = new PrintWriter(System.out,true);
        //pw = new PrintWriter(new File("C://Users/Aman deep/Desktop/output.txt"));  
        StringBuilder sb = new StringBuilder();
        int n = ni();
        int min[][] = new int[n][n];
        for(int i=0;i<n;++i)
            for(int j=0;j<n;++j)
                min[i][j] = -1;
        LinkedList<Pair> queue = new LinkedList();
        int xs = ni(),ys = ni(),xd = ni(),yd = ni();
        min[xd][yd] = 0;
        queue.add(new Pair(xd,yd));
        while(!queue.isEmpty())
        {
            Pair curr =  queue.poll();
            for(int i=0;i<6;++i)
            {
                int nx = curr.x+dx[i];
                int ny = curr.y+dy[i];
                if(nx>=0 && nx<n && ny>=0 && ny<n && min[nx][ny]==-1)
                {
                    min[nx][ny] = 1+min[curr.x][curr.y];
                    queue.add(new Pair(nx,ny));
                }
            }
        }
        if(min[xs][ys]==-1)
           pl("Impossible");
        else
        {   
            /*pl("min array : ");
            for(int i=0;i<n;++i)
            {
                for(int j=0;j<n;++j)
                    p(min[i][j]+" ");
                pl();
            }*/
            pl(min[xs][ys]);
            int currx = xs;
            int curry = ys;
            while(true)
            {  
                //pl("currx : "+currx+" curry : "+curry);
                if(currx==xd && curry==yd)
                    break;
                for(int i=0;i<6;++i)
                {
                    int nx = currx+dx[i];
                    int ny = curry+dy[i];
                    if(nx>=0 && ny>=0 && nx<n && ny<n && min[nx][ny]==min[currx][curry]-1)
                    {
                        currx+=dx[i];
                        curry+=dy[i];
                        p(type[i]);
                        break;
                    }
                }
            }
            pl();
        }
        Calendar CAL2 = Calendar.getInstance();
        CAL2.setTime(new Date());
        double Execution_Time = (double)(CAL2.getTimeInMillis()-CAL1.getTimeInMillis())/1000.000;
        //System.out.println("Execution time : "+Execution_Time+" seconds");
        pw.flush();
        pw.close();
    }
    static class Pair
    {
        int x,y;
        Pair(int x,int y)
        {
            this.x=x;
            this.y=y;
        }
    }
    static boolean islong(double d)
    {
        return Math.ceil(d)==d;
    }
    static double roundLikeCpp(double d,double precision)
    {   
        if(islong(d))
            return d;
        d*=(long)pow(10,precision+1);
        if(d%10==5)
            d--;
        return d/pow(10,precision+1);
    }
    static class Reader {
    final private int BUFFER_SIZE = 1 << 16;
    private DataInputStream din;
    private byte[] buffer;
    private int bufferPointer, bytesRead;

    public Reader() {
        din = new DataInputStream(System.in);
        buffer = new byte[BUFFER_SIZE];
        bufferPointer = bytesRead = 0;
    }

    public Reader(String file_name) throws IOException {
        din = new DataInputStream(new FileInputStream(file_name));
        buffer = new byte[BUFFER_SIZE];
        bufferPointer = bytesRead = 0;
    }

    public String readLine() throws IOException {
        byte[] buf = new byte[64];
        int cnt = 0, c;
        while ((c = read()) != -1) {
            if (c == '\n') break;
            buf[cnt++] = (byte) c;
        }
        return new String(buf, 0, cnt);
    }

    public int nextInt() throws IOException {
        int ret = 0;
        byte c = read();
        while (c <= ' ') c = read();
        boolean neg = (c == '-');
        if (neg) c = read();
        do {
            ret = ret * 10 + c - '0';
        } while ((c = read()) >= '0' && c <= '9');
        if (neg) return -ret;
        return ret;
    }

    public long nextLong() throws IOException {
        long ret = 0;
        byte c = read();
        while (c <= ' ') c = read();
        boolean neg = (c == '-');
        if (neg) c = read();
        do {
            ret = ret * 10 + c - '0';
        } while ((c = read()) >= '0' && c <= '9');
        if (neg) return -ret;
        return ret;
    }

    public double nextDouble() throws IOException {
        double ret = 0, div = 1;
        byte c = read();
        while (c <= ' ') c = read();
        boolean neg = (c == '-');
        if (neg) c = read();
        do {
            ret = ret * 10 + c - '0';
        } while ((c = read()) >= '0' && c <= '9');
        if (c == '.') while ((c = read()) >= '0' && c <= '9') ret += (c - '0') / (div *= 10);
        if (neg) return -ret;
        return ret;
    }

    private void fillBuffer() throws IOException {
        bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
        if (bytesRead == -1) buffer[0] = -1;
    }

    private byte read() throws IOException {
        if (bufferPointer == bytesRead) fillBuffer();
        return buffer[bufferPointer++];
    }

    public void close() throws IOException {
        if (din == null) return;
        din.close();
    }
}
     static class MyFileReader                                          //File input template
    {
        StringTokenizer st;
        BufferedReader br;
        MyFileReader() throws IOException
        {
            br = new BufferedReader(new FileReader("C://Users/Aman deep/Desktop/input.txt"));
        }
        String nextLine() throws IOException
        {
            return br.readLine();
        }
        String next() throws IOException
        {
            if(st==null || !st.hasMoreTokens())
                st = new StringTokenizer(nextLine());
            return st.nextToken();
        }
        int nextInt() throws IOException
        {
            return Integer.parseInt(next());
        }
        long nextLong() throws IOException
        {
            return Long.parseLong(next());
        }
        double nextDouble() throws IOException
        {
            return Double.parseDouble(next());
        }
    }
     static class MyFileReader1                                          //File input template
    {
        StringTokenizer st;
        BufferedReader br;
        MyFileReader1() throws IOException
        {
            br = new BufferedReader(new FileReader("C://Users/Aman deep/Desktop/output.txt"));
        }
        String nextLine() throws IOException
        {
            return br.readLine();
        }
        String next() throws IOException
        {
            if(st==null || !st.hasMoreTokens())
                st = new StringTokenizer(nextLine());
            return st.nextToken();
        }
        int nextInt() throws IOException
        {
            return Integer.parseInt(next());
        }
        long nextLong() throws IOException
        {
            return Long.parseLong(next());
        }
        double nextDouble() throws IOException
        {
            return Double.parseDouble(next());
        }
    }
}