#include <bits/stdc++.h>
using namespace std;
typedef unsigned int ui;
typedef unsigned long ul;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<unsigned int> vui;
typedef vector<vi> vvi;
typedef pair<int,int> ii;
typedef vector<ii> vii;
const int INF = int (1e9) + int (1e5);
const ll INFL = ll(2e18) + ll(1e10);
const ui M = 1E9 + 7;
const double eps = 1e-9;

#define MP make_pair
#define UNVISITED 0

vii moves;

struct graph {
    int N;
    vvi dist;
    vector<vvi> path;
    graph(int n) : N(n) {dist.resize(n,vi(n,INF));path.resize(n,vvi (n));}

    /// DIJKSTRA ///
    ui dijkstra(int si,int sj, int ti,int tj) {
        priority_queue<vi, vvi, greater<vi> > Q;
        Q.push(vi{0,si,sj});
        dist[si][sj] = 0;
        while(Q.size()) {
            vi p = Q.top(); Q.pop();
            if(p[1] == ti && p[2]== tj) break;
            for(int idx=0;idx<6;idx++){
                int x=p[1]+moves[idx].first;
                int y=p[2]+moves[idx].second;
                if (x>=0 && x<N && y>=0 && y<N){
                    if (dist[p[1]][p[2]]+1<dist[x][y]){
                        dist[x][y] = dist[p[1]][p[2]]+1;
                        path[x][y] = path[p[1]][p[2]];
                        path[x][y].push_back(idx);
                        Q.push(vi {dist[x][y],x,y});
                    }else if (dist[p[1]][p[2]]+1==dist[x][y]){
                        for (int j=0;j<path[p[1]][p[2]].size();j++){
                            if (path[x][y][j]>path[p[1]][p[2]][j]){
                                for (int jj=j;jj<path[p[1]][p[2]].size();jj++) path[x][y][jj]=path[p[1]][p[2]][jj];
                                path[x][y][path[x][y].size()-1]=idx;
                                Q.push(vi {dist[x][y],x,y});
                                break;
                            }
                            else if (path[x][y][j]<path[p[1]][p[2]][j]) break;
                        }
                    }
                }
            }
        }
        return dist[ti][tj];
    }
};

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.
    moves = {MP(-2,-1),MP(-2,1),MP(0,2),MP(2,1),MP(2,-1),MP(0,-2)};
    vector<string> cmoves = {"UL", "UR", "R", "LR", "LL", "L"};
    graph g(n);
    ui l=g.dijkstra(i_start,j_start,i_end,j_end);
    if (g.dist[i_end][j_end]<INF){
        cout << l << endl;
        vi path(l);
        for (int idx : g.path[i_end][j_end]){
            cout << cmoves[idx] << " ";
        }
    }
    else{
        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;
    printShortestPath(n, i_start, j_start, i_end, j_end);
    return 0;
}