#include <bits/stdc++.h>

using namespace std;
class Point
{
    public:
    Point(){x = -1;y=-1;distsofar = 0;}  
    int x;
    int y;    
    int distsofar ;
    string dir;
};
bool flags[201][201] = {false,false};
bool pointequals(Point a, Point b)
{
    return a.x == b.x && a.y == b.y;
}

Point LR(int n , Point p)
{
    Point ret ;
    if(p.x+2 < n && p.y+1 < n)
    {
        ret.x = p.x+2;
        ret.y = p.y+1;
        ret.distsofar = p.distsofar+1;
        ret.dir = p.dir+"LR ";
    }
    return ret;
}

Point UR(int n , Point p)
{
    Point ret ;
    if(p.x-2 > -1 && p.y+1 < n)
    {
        ret.x = p.x-2;
        ret.y = p.y+1;
        ret.distsofar = p.distsofar+1;
        ret.dir = p.dir+"UR ";
    }
    return ret;
}

Point LL(int n , Point p)
{
    Point ret;
    if(p.x+2 < n && p.y-1 > 0)
    {
        ret.x = p.x+2;
        ret.y = p.y-1;
        ret.distsofar = p.distsofar+1;
        ret.dir = p.dir+"LL ";
    }
    return ret;
}
Point UL(int n , Point p)
{
    Point ret;
    if(p.x-2 > -1 && p.y-1 > -1)
    {
        ret.x = p.x-2;
        ret.y = p.y-1;
        ret.distsofar = p.distsofar+1;
        ret.dir = p.dir+"UL ";
    }
    return ret;
}

Point L(int n , Point p)
{
    Point ret;
    if(p.y-2 > -1 )
    {
        ret.x = p.x;
        ret.y = p.y-2;
        ret.distsofar = p.distsofar+1;
        ret.dir = p.dir+"L ";
    }
    return ret;
}
Point R(int n , Point p)
{
    Point ret ;
    if(p.y+2 < n)
    {
        ret.x = p.x;
        ret.y = p.y+2;
        ret.distsofar = p.distsofar+1;
        ret.dir = p.dir+"R ";
    }
    return ret;
}
// UL, UR, R, LR, LL, L

string run(int n, Point p ,Point q, int* moves)
{
    std::queue<Point> myq;
    
    myq.push(p);
    
    while(!myq.empty())
    {
        Point a =  myq.front();
        myq.pop();
      //  std::cout<<a.x << " "<<a.y <<"->"<<std::endl;
        
        if(pointequals(a,q))
        {
            //std::cout<<a.distsofar;
            *moves = a.distsofar;
            return a.dir;
        }
        
        auto p1 = UL(n,a);
        if(p1.x != -1 && p1.y != -1 &&flags[p1.x][p1.y] == false)
        {
            flags[p1.x][p1.y] = true;
            myq.push(p1);
        }
        
        auto p2 = UR(n,a);
        if(p2.x != -1 && p2.y != -1 && !flags[p2.x][p2.y]){flags[p2.x][p2.y] = true;myq.push(p2);}
        
        auto p3 = R(n,a);
        if(p3.x != -1 && p3.y != -1 && !flags[p3.x][p3.y]){flags[p3.x][p3.y] = true;myq.push(p3);}
        
        auto p4 = LR(n,a);
        if(p4.x != -1&& p4.y != -1 && !flags[p4.x][p4.y]){flags[p4.x][p4.y] = true;myq.push(p4);}
        
        auto p5 = LL(n,a);
        if(p5.x != -1&& p5.y != -1 && !flags[p5.x][p5.y]){flags[p5.x][p5.y] = true;myq.push(p5);}
        
        auto p6 = L(n,a);
        if(p6.x != -1&& p6.y != -1 && !flags[p6.x][p6.y]){flags[p6.x][p6.y] = true;myq.push(p6);}
        
        
        
        
    }
    
    return "Impossible";
}

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.
    
    Point st;
    st.x = i_start;
    st.y = j_start;
    
    Point end; 
    end.x = i_end;
    end.y = j_end;
    
    int moves = 0 ;
    string dirs =  run(n,st,end,&moves);
    
    if(moves > 0 )std::cout<<moves<<"\n";
    std::cout<<dirs;
}

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;
}