#include <bits/stdc++.h>

using namespace std;

struct Point
{
    int x;
    int y;
};

// An Data Structure for queue used in BFS
struct queueNode
{
    Point pt;  // The cordinates of a cell
    int dist;  // cell's distance of from the source
    string path;
};


bool valid(int row, int col,int ROW,int COL)
{

    return (row >= 0) && (row < ROW) &&
           (col >= 0) && (col < COL);
}


int rowNum[] = {-2, -2, 0, 2,2,0};
int colNum[] = {-1, 1, 2, 1,-1,-2};

void printShortestPath(int n,Point src,Point dest ) {

    bool visited[n][n];
    memset(visited, false, sizeof visited);


    visited[src.x][src.y] = true;

    queue<queueNode> q;

    queueNode s = {src, 0};
    q.push(s);
    int c=0;

    while (!q.empty())
    {
        queueNode curr = q.front();
        Point pt = curr.pt;
        //string str= curr.path;

        if (pt.x == dest.x && pt.y == dest.y)
            {cout<<curr.dist<<endl;
            cout<<curr.path;
            c=1;
            break;
            }

        q.pop();

        for (int i = 0; i < 6; i++)
        {
            int row = pt.x + rowNum[i];
            int col = pt.y + colNum[i];


            if (valid(row, col,n,n) && !visited[row][col])
            {
                // mark cell as visited and enqueue it
                visited[row][col] = true;
                queueNode Adjcell;
                if(i==0)
                {
                    Adjcell = { {row, col},curr.dist + 1,curr.path + "UL " };}
                  if(i==1)
                {
                    Adjcell = { {row, col},curr.dist + 1,curr.path + "UR "};}
                     if(i==2)
                {
                    Adjcell = { {row, col},curr.dist + 1,curr.path + "R " };}
                     if(i==3)
                {
                 Adjcell = { {row, col},curr.dist + 1,curr.path + "LR "};}
                     if(i==4)
                {
                    Adjcell = { {row, col},curr.dist + 1,curr.path+ "LL " };}
                     if(i==5)
                {
                    Adjcell = { {row, col},curr.dist + 1,curr.path+ "L " };}
                q.push(Adjcell);
            }
        }
    }
    if(!c)
    cout<<"Impossible";
}

int main() {
    int n;
    cin >> n;
    int i_start;
    int j_start;
    int i_end;
    int j_end;

    cin >> i_start >> j_start >> i_end >> j_end;
    Point src= {i_start,j_start};
    Point dest= {i_end,j_end};
    printShortestPath(n, src,dest);
    return 0;
}