#include <vector>
#include <queue>
#include <iostream>
#include <algorithm>
using namespace std;

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

    vector < vector < pair<int, string> > > g(n*n);
    vector< vector<int> > v(n, vector<int>(n));

    int r = 0;
    for (int i = 0; i<n; i++) {
        for (int j = 0; j<n; j++) {
            v[i][j] = r;
            r++;
        }
    }
    for (int i = 0; i<n; i++) {
        for (int j = 0; j<n; j++) {
            int cur = v[i][j];
            if (j+2 < n) {
                 g[cur].push_back(make_pair(v[i][j+2], "L"));
                 g[v[i][j+2]].push_back(make_pair(cur, "R"));
            }
            if (j-2 >= 0) {
                g[cur].push_back(make_pair(v[i][j-2], "R"));
                g[v[i][j-2]].push_back(make_pair(cur, "L"));
            }
            if (j+1 < n && i-2 >= 0) {
                g[cur].push_back(make_pair(v[i-2][j+1], "UR"));
                g[v[i-2][j+1]].push_back(make_pair(cur, "UL"));
            }
            if (j-1 >= 0 && i-2 >= 0) {
                g[cur].push_back(make_pair(v[i-2][j-1], "UL"));
                g[v[i-2][j-1]].push_back(make_pair(cur, "UR"));
            }

            if (j+1 < n && i+2 < n) {
                g[cur].push_back(make_pair(v[i+2][j+1], "LL"));
                g[v[i+2][j+1]].push_back(make_pair(cur, "LR"));
            }
            if (j-1 >= 0 && i+2 < n) {
                g[cur].push_back(make_pair(v[i+2][j-1], "LR"));
                g[v[i+2][j-1]].push_back(make_pair(cur, "LL"));
            }
        }
    }

    int s = v[i_start][j_start];
    int to = v[i_end][j_end];
    queue<int> q;
    q.push (s);
    vector<bool> used (n*n);
    vector<int> d (n*n), p (n*n);
    used[s] = true;
    p[s] = -1;
    while (!q.empty()) {
	   int v = q.front();
	   q.pop();
	   for (size_t i=0; i<g[v].size(); ++i) {
		  int to = g[v][i].first;
		  if (!used[to]) {
			 used[to] = true;
			 q.push (to);
			 d[to] = d[v] + 1;
			 p[to] = v;
		  }
	   }
    }

    if (!used[to]) {
        cout << "Impossible";
    } else {
	   vector<int> path;
	   for (int v=to; v!=-1; v=p[v])
		  path.push_back (v);
	   reverse (path.begin(), path.end());
        int pre = s;
        cout << path.size()-1 << endl;
	   for (size_t i=1; i<path.size(); ++i) {
           int cur = path[i];
           if (pre - cur == 2) {
               cout << "L ";
           }
           if (pre - cur == -2) {
               cout << "R ";
           }
           if (pre - cur == (n*2 + 1)) {
               cout << "UL ";
           }
           if (pre - cur == (n*2 - 1)) {
               cout << "UR ";
           }
           if (pre - cur == -(n*2 - 1)) {
               cout << "LR ";
           }
           if (pre - cur == -(n*2 - 1)) {
               cout << "LL ";
           }
           pre = cur;
       }
    }

}

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