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

class RedKnightShortestPath {
    public static void main(String args[]) {
        try {
            InputReader in = new InputReader(System.in);
            BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
            int n = in.readInt();
            String[] order = new String[]{"UL", "UR", "R", "LR", "LL", "L"};
            int sx = in.readInt();
            int sy = in.readInt();
            int temp = sx;
            sx = sy;
            sy = temp;
            int ex = in.readInt();
            int ey = in.readInt();
            temp = ex;
            ex = ey;
            ey = temp;
            Queue<Cell> q = new LinkedList<>();
            q.add(new Cell(sx, sy, ""));
            Vector<String> answers = new Vector<>();
            boolean vis[][] = new boolean[n][n];
            while(!q.isEmpty()) {
                Cell c = q.poll();
//                System.out.println(c);
                if (c.x == ex && c.y == ey) {
                    answers.add(c.res);
                    break;
                }
                if (vis[c.x][c.y]) {
                    continue;
                }
                vis[c.x][c.y] = true;
                if (c.x - 1 >= 0 && c.y - 2 >= 0) {
                    q.add(new Cell(c.x - 1, c.y - 2, c.res + " UL"));
                }
                if (c.x + 1 < n && c.y - 2 >= 0) {
                    q.add(new Cell(c.x + 1, c.y - 2, c.res + " UR"));
                }
                if (c.x - 1 >= 0 && c.y + 2 < n) {
                    q.add(new Cell(c.x - 1, c.y + 2, c.res + " LL"));
                }
                if (c.x + 1 < n && c.y + 2 < n) {
                    q.add(new Cell(c.x + 1, c.y + 2, c.res + " LR"));
                }
                if (c.x + 2 < n) {
                    q.add(new Cell(c.x + 2, c.y, c.res + " R"));
                }
                if (c.x - 2 >= 0) {
                    q.add(new Cell(c.x - 2, c.y, c.res + " L"));
                }
            }
            Collections.sort(answers, new Comparator<String>() {
                @Override
                public int compare(String o1, String o2) {
                    if (o1.length() > o2.length()) {
                        return 1;
                    }
                    else if (o1.length() == o2.length()) {
                        String first[] = o1.split(" ");
                        String second[] = o2.split(" ");
                        for (int i = 0; i < first.length; i++) {
                            int indexF = -1;
                            int indexS = -1;
                            for (int j = 0; j < order.length; j++) {
                                if (first[i].equals(order[j])) {
                                    indexF = j;
                                }
                                if (second[i].equals(order[j])) {
                                    indexS = j;
                                }
                            }
                            if (indexF < indexS) {
                                return -1;
                            }
                            else if (indexF > indexS) {
                                return 1;
                            }
                        }
                    }
                    return -1;
                }
            });
            if (answers.size() >= 1) {
                String resans[] = answers.get(0).split(" ");
                Vector<String> res = new Vector<String>();
                for (String s: resans) {
                    if (s.equals(""))
                        continue;
                    res.add(s);
                }
                Collections.sort(res, new Comparator<String>() {
                    @Override
                    public int compare(String o1, String o2) {
                        int indexF = -1;
                        int indexS = -1;
                        for (int j = 0; j < order.length; j++) {
                            if (o1.trim().equals(order[j])) {
                                indexF = j;
                            }
                            if (o2.trim().equals(order[j])) {
                                indexS = j;
                            }
                        }
                        if (indexF < indexS) {
                            return -1;
                        }
                        else if (indexF > indexS) {
                            return 1;
                        }
                        return 0;
                    }
                });
                out.write(Integer.toString(res.size()));
                out.newLine();
                for (String sortedRes: res) {
                    out.write(sortedRes.trim() + " ");
                }
                out.newLine();
            }
            else {
                out.write("Impossible");
                out.newLine();
            }
            out.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private static class Cell {
        int x, y;
        String res;

        public Cell(int x, int y, String res) {
            this.x = x;
            this.y = y;
            this.res = res;
        }

        @Override
        public String toString() {
            return this.x + " "+this.y + " "+this.res;
        }
    }
}
class InputReader {
    private boolean finished = false;

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public 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++];
    }

    public int peek() {
        if (numChars == -1)
            return -1;
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                return -1;
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar];
    }

    public int readInt() {
        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;
    }

    public long readLong() {
        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;
    }

    public String readString() {
        int length = readInt();
        if (length < 0)
            return null;
        byte[] bytes = new byte[length];
        for (int i = 0; i < length; i++)
            bytes[i] = (byte) read();
        try {
            return new String(bytes, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            return new String(bytes);
        }
    }

    public static boolean isSpaceChar(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    private String readLine0() {
        StringBuffer buf = new StringBuffer();
        int c = read();
        while (c != '\n' && c != -1) {
            if (c != '\r')
                buf.appendCodePoint(c);
            c = read();
        }
        return buf.toString();
    }

    public String readLine() {
        String s = readLine0();
        while (s.trim().length() == 0)
            s = readLine0();
        return s;
    }

    public String readLine(boolean ignoreEmptyLines) {
        if (ignoreEmptyLines)
            return readLine();
        else
            return readLine0();
    }

    public BigInteger readBigInteger() {
        try {
            return new BigInteger(readString());
        } catch (NumberFormatException e) {
            throw new InputMismatchException();
        }
    }

    public char readCharacter() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        return (char) c;
    }

    public double readDouble() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        double res = 0;
        while (!isSpaceChar(c) && c != '.') {
            if (c == 'e' || c == 'E')
                return res * Math.pow(10, readInt());
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        }
        if (c == '.') {
            c = read();
            double m = 1;
            while (!isSpaceChar(c)) {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, readInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                m /= 10;
                res += (c - '0') * m;
                c = read();
            }
        }
        return res * sgn;
    }

    public boolean isExhausted() {
        int value;
        while (isSpaceChar(value = peek()) && value != -1)
            read();
        return value == -1;
    }

    public String next() {
        return readString();
    }

    public boolean readBoolean() {
        return readInt() == 1;
    }
}