#include <iostream>
#include<queue>
#include<vector>
#include<fstream>

using namespace std;


int n , moves = 0;
int i_start;
    int j_start;
    int i_end;
    int j_end;


vector<string> path;
struct board{
  
  bool visited = 0;


  unsigned short int x,y,par_x,par_y; 

  /*void operator = (const board &dum){
      visited = dum.visited;
      x = dum.x;
      y = dum.y;
      par_x = dum.par_x;
      par_y = dum.par_y;

  }*/

};

board newb[200][200];


queue<board> moverq;


bool out_of_bounds(int x, int y){


    if(x < 0 || y < 0 || x > n-1 || y > n-1)
        return true;

    else
        return false;

}


int backtrace(int x, int y){



    board now = newb[x][y];

    if(now.par_x == -1 && now.par_y == -1)
        return 1;


    if(x - now.par_x == -2    &&  y - now.par_y == -1){
        path.push_back("UL"); moves++;
        int UL = backtrace(x+2, y+1);
    }


    else if(x - now.par_x == -2   &&  y - now.par_y == 1){
        path.push_back("UR"); moves++;
        int UR = backtrace(x+2, y-1);
    }


    else if(x - now.par_x == 0   &&  y - now.par_y == -2){
        path.push_back("L");  moves++;
        int L = backtrace(x, y+2);
    }



    else if(x - now.par_x == 0   &&  y - now.par_y ==2){
        path.push_back("R");   moves++;
        int R = backtrace(x, y-2);
    }



    else if(x - now.par_x == 2   &&  y - now.par_y ==-1){
        path.push_back("LL");   moves++;
        int LL = backtrace(x-2, y+1);
    }



    else if(x - now.par_x == 2   &&  y - now.par_y == 1){
        path.push_back("LR");   moves++;
        int LR = backtrace(x-2, y-1);
    }



     return 0;

}









void visit(int x, int y, int parent_x, int parent_y){

   if(!out_of_bounds(x,y)){
   //cout<<endl<<x<<" "<<y<<" "<<parent_x<<" "<<parent_y<<endl;
   newb[x][y].visited = true;

   newb[x][y].par_x = parent_x;
   newb[x][y].par_y = parent_y;

   moverq.push(newb[x][y]);
   }



}


int BFS(int x, int y){



    if(out_of_bounds(x,y))
        return 0;


    if(x == i_end && y == j_end){


        backtrace(x,y);
        return 1;
    }



    if(x == i_start && y == j_start){

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

         newb[x][y].par_x = -1;
         newb[x][y].par_y = -1;
    }




    if(newb[x-2][y-1].visited == false){


        visit(x-2, y-1, x, y);
    }

    if(newb[x-2][y+1].visited == false){
        visit(x-2, y+1, x, y);
    }

    if(newb[x][y+2].visited == false){
        visit(x, y+2, x, y);
    }

    if(newb[x+2][y+1].visited == false){
        visit(x+2, y+1, x , y);
    }

    if(newb[x+2][y-1].visited == false){
        visit(x+2, y-1, x, y);
    }

    if(newb[x][y-2].visited == false){
        visit(x, y-2, x, y);
    }

    //cout<<"\nbfs gets called!\n";

    return 0;






}



void printShortestPath(int n, int i_start, int j_start, int i_end, int j_end) {

    board startcell;
    startcell.x = i_start;
    startcell.y = j_start;




    moverq.push(startcell);

    int foundya = 0;
    while(moverq.empty() == false ){

         board frontcell = moverq.front();
         moverq.pop();
         int newcall = BFS(frontcell.x, frontcell.y);
        // cout<<moves;
        // moves++;

         foundya = newcall;
    }

  if(moves == 0)
      cout<<"Impossible"<<endl;


  else{
   cout<<moves<<endl;


   for(int i = path.size()-1; i >=0; i--)
      cout<<path[i]<<" ";
  
  }


}

int main()

{


    

    cin>>n;


    for(int i = 0; i < n; i++){
        for(int j = 0; j < n; j++){
            newb[i][j].x = i;
            newb[i][j].y = j;
        }
    }
    cin >> i_start >> j_start >> i_end >> j_end;
    printShortestPath(n, i_start, j_start, i_end, j_end);

    return 0;
}