#include <math.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#include <limits.h>
#include <stdbool.h>

typedef struct stepRec{
    int prev;
    int dir;
}stepRec;

int pointToIndex(int n, int i, int j){
    return (i*n+j);
}

int* getNeighbors(int n, int ind){
    int *A = malloc(sizeof(int) * 6);
    for (int i=0; i<6; i++)
        A[i] = -1;
    int i = ind / n;
    int j = ind - (i * n);
    
    if (i > 1) {
        if (j > 0) 
            A[0] = (i-2)*n + (j-1); // UpperLeft
        if (j+1 < n)
            A[1] = (i-2)*n + (j+1); // UpperRight
    }
    if (j+2 < n)
        A[2] = i*n + (j+2); //Right
    if (i+2 < n) {
        if (j+1 < n)
            A[3] = (i+2)*n + (j+1); // LowerRight
        if (j > 0) 
            A[4] = (i+2)*n + (j-1); // LowerLeft
    }
    if (j-2 >= 0)
        A[5] = i*n + (j-2); // Left
    
    return A;
}

void printShortestPath(int n, int i_start, int j_start, int i_end, int j_end) {
    //  Print the distance along with the sequence of moves.
    if ((i_start-i_end) % 2 != 0) {
        printf("Impossible\n");
        return;
    }
    
    int nn = n * n;
    int *moves = malloc(sizeof(int) * nn);   
    int *queue = malloc(sizeof(int) * nn);
    stepRec *steps = malloc(sizeof(stepRec) * nn);
    for (int i=0; i<nn; i++) {
        moves[i] = -1;
        queue[i] = -1;
        steps[i].prev = -1;
        steps[i].dir = -1;
    }
    int start_ind = pointToIndex(n, i_start, j_start);
    int end_ind = pointToIndex(n, i_end, j_end);
    moves[start_ind] = 0;
    steps[start_ind].prev = start_ind;
    
    int q_pop = 0;
    int q_push = 0;
    queue[q_push++] = start_ind;
    
    while (q_pop <= q_push) {
        int *neighbors = getNeighbors(n, queue[q_pop]);
        for (int i=0; i<6; i++) {
            if (neighbors[i] >= 0) {
                if (moves[neighbors[i]] == -1) {
                    moves[neighbors[i]] = moves[queue[q_pop]] + 1;
                    steps[neighbors[i]].prev = queue[q_pop];
                    steps[neighbors[i]].dir = i;
                    if (neighbors[i] == end_ind) {
                        printf("%d\n", moves[neighbors[i]]);
                        
                        int k = end_ind; 
                        static char *dirs[] = {"UL ", "UR ", "R ", "LR ", "LL ", "L "};
                        int *path = malloc(sizeof(int)*moves[neighbors[i]]);
                        for (int j=moves[neighbors[i]]-1; j>=0; j--){
                            path[j] = steps[k].dir;
                            k = steps[k].prev;
                        }
                        for (int j=0; j<moves[neighbors[i]]; j++)
                            printf("%s", dirs[path[j]]);
                        
                        printf("\n");                         
                        free(path);
                        return;
                    }
                    queue[q_push++] = neighbors[i];
                }
            }
        }
        
        free(neighbors);
        q_pop++;
    }

    printf("Impossible\n");

    
    free(queue);
    free(moves);
}

int main() {
    int n; 
    scanf("%i", &n);
    int i_start; 
    int j_start; 
    int i_end; 
    int j_end; 
    scanf("%i %i %i %i", &i_start, &j_start, &i_end, &j_end);
    printShortestPath(n, i_start, j_start, i_end, j_end);
    return 0;
}