#include <bits/stdc++.h>
#include <queue>
using namespace std;
struct point
{
    int x;
    int y;
    vector<string>path;
    //int distance;
    
};
bool isvalid(point temp,int n)
{
    if(temp.x<n&&temp.y<n&&temp.x>=0&&temp.y>=0)
        {
            return 1;
        }
    else
        return 0;
}
void printPath(vector<string>v)
{
    for (auto i = v.begin(); i != v.end(); ++i)
        cout <<*i<<" " ;
    
}
void printShortestPath(int n, int i_start, int j_start, int i_end, int j_end) {
    queue <point> q;
    vector <string>path;
    path.push_back("");
    int flag=0;
    point source,destination;
    source.x=i_start;
    source.y=j_start;
    //source.distance=0
    //source.path=path;
    path.pop_back();
    destination.x=i_end;
    destination.y=j_end;
    q.push(source);
    int moves;
    bool visited[n][n];
    memset(visited, false, sizeof visited);
    visited[source.x][source.y] = true;
    while(!q.empty())
    {
            point point1=q.front();
            q.pop();
            path=point1.path;
            if (point1.x==destination.x&&point1.y==destination.y)
            {
                cout<<path.size()<<endl;
                printPath(path);
                //moves=point1.distance;
                flag=1;
                break;
            }
            point UL,UR,R,LR,LL,L;
            
            UL.x=point1.x-2;
            UL.y=point1.y-1;
            path.push_back("UL");
            UL.path=path;
            path.pop_back();
            //UL.distance=point1.distance+1;
            if(isvalid(UL,n)&&!visited[UL.x][UL.y]){
                q.push(UL);
                visited[UL.x][UL.y]=true;
                

            }
            UR.x=point1.x-2;
            UR.y=point1.y+1;
            path.push_back("UR");
            UR.path=path;
            path.pop_back();
            //UR.distance=point1.distance+1;
            if(isvalid(UR,n)&&!visited[UR.x][UR.y]){
                 q.push(UR);
                visited[UR.x][UR.y]=true;
                

            }
            R.x=point1.x;
            R.y=point1.y+2;
            path.push_back("R");
            R.path=path;
            path.pop_back();
            //R.distance=point1.distance+1;
            if(isvalid(L,n)&&!visited[R.x][R.y]){
                 q.push(L);
                visited[R.x][R.y]=true;
                

            }
            LR.x=point1.x+2;
            LR.y=point1.y+1;
            path.push_back("LR");
            LR.path=path;
            path.pop_back();
            //LR.distance=point1.distance+1;
            if(isvalid(LR,n)&&!visited[LR.x][LR.y]){
                 q.push(LR);
                visited[LR.x][LR.y]=true;
                

            }
            LL.x=point1.x+2;
            LL.y=point1.y-1;
            //LL.distance=point1.distance+1;
            path.push_back("LL");
            LL.path=path;
            path.pop_back();
            
            if(isvalid(LL,n)&&!visited[LL.x][LL.y]){
                 q.push(LL);
                 visited[LL.x][LL.y]=true;
                

            }   
            L.x=point1.x;
            L.y=point1.y-2;
            path.push_back("L");
            L.path=path;
            path.pop_back();
            //L.path=point1.distance+1;
            if(isvalid(L,n)&&!visited[L.x][L.y]){
                q.push(L);
                visited[L.x][L.y]=true;
                
                

            }
    }
    if(!flag)
        cout<<"Impossible"<<endl;
    /*//else
    //    cout<<"Impossible"<<endl;
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            cout<<visited[i][j]<<" ";
            
        }
        cout<<endl;*/   
}
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;
    printShortestPath(n, i_start, j_start, i_end, j_end);
    return 0;
}