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

public class Solution {
    
    static boolean isEmptyCell(Cell[][] grid, int n, int i, int j) {
        return i >= 0 && i < n && j >= 0 && j < n && grid[i][j] == null;
    }

    static void printShortestPath(int n, int i_start, int j_start, int i_end, int j_end) {
        Cell[][] grid = new Cell[n][n];
        Queue<Cell> q = new ArrayDeque<>();
        grid[i_start][j_start] = new Cell(i_start, j_start, 0, -1, -1, "");
        q.offer(grid[i_start][j_start]);
        while (!q.isEmpty()) {
            Cell c = q.poll();
            if (c.i == i_end && c.j == j_end) {
                System.out.println(c.v);
                backtrack(grid, n, c);
                return;
            }
            addNeighbors(q, grid, n, c.i, c.j, c.v + 1);
        }
        System.out.println("Impossible");
    }
    
    static void backtrack(Cell[][] grid, int n, Cell end) {
        ArrayList<String> directions = new ArrayList<>();
        while (true) {
            directions.add(end.dir);
            if (end.prev_i >= 0 && end.prev_j >= 0) {
                end = grid[end.prev_i][end.prev_j];
            }
            else {
                break;
            }
        }
        Collections.reverse(directions);
        for (String dir : directions) {
            if (!("".equals(dir))) {
                System.out.print(dir + " ");
            }
        }
        System.out.println("");
    }
    
    static class Cell {
        int i;
        int j;
        int v;
        int prev_i;
        int prev_j;
        String dir;
        Cell(int i, int j, int v, int prev_i, int prev_j, String dir) {
            this.i = i;
            this.j = j;
            this.v = v;
            this.prev_i = prev_i;
            this.prev_j = prev_j;
            this.dir = dir;
        }
    }
    
    static void addNeighbors(Queue<Cell> q, Cell[][] grid, int n, int i, int j, int v) {
        addNeighborIfEmpty(q, grid, n, i-2, j-1, v, i, j, "UL");
        addNeighborIfEmpty(q, grid, n, i-2, j+1, v, i, j, "UR");
        addNeighborIfEmpty(q, grid, n, i, j+2, v, i, j, "R");
        addNeighborIfEmpty(q, grid, n, i+2, j+1, v, i, j, "LR");
        addNeighborIfEmpty(q, grid, n, i+2, j-1, v, i, j, "LL");
        addNeighborIfEmpty(q, grid, n, i, j-2, v, i, j, "L");
    }
    
    static void addNeighborIfEmpty(Queue<Cell> q, Cell[][] grid, int n, int i, int j, int v, int prev_i, int prev_j, String dir) {
        if (isEmptyCell(grid, n, i, j)) {
            grid[i][j] = new Cell(i, j, v, prev_i, prev_j, dir);
            q.offer(grid[i][j]);
        }
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int i_start = in.nextInt();
        int j_start = in.nextInt();
        int i_end = in.nextInt();
        int j_end = in.nextInt();
        printShortestPath(n, i_start, j_start, i_end, j_end);
        in.close();
    }
}