#include <bits/stdc++.h>

using ll = long long;
ll constexpr INF = 1e18;

struct Point {
    int x, y;
    std::string dir;

    Point() {
        x = y = 0;
        dir = "";
    }

    Point(int _x, int _y) {
        x = _x;
        y = _y;
    }

    bool operator<(const Point &r) const {
        if (x < r.x) return true;
        if (x > r.x) return false;
        if (y < r.y) return true;

        return false;
    }

    bool operator==(const Point &r) const {
        return x == r.x && y == r.y;
    }
};

bool inside(int n, const Point &s) {
    return s.x >= 0 && s.x < n && s.y >= 0 && s.y < n;
}

void solve(int n, Point start, Point end) {
    std::queue<Point> q;
    std::set<Point> seen;

    Point board[n][n];
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            board[i][j].x = i;
            board[i][j].y = j;
        }
    }

    q.push(start);
    seen.insert(start);

    while (!q.empty()) {
        Point s = q.front();
        q.pop();
        std::string dir;

        Point UL(s.x - 2, s.y - 1), UR(s.x - 2, s.y + 1), R(s.x, s.y + 2),
              LR(s.x + 2, s.y + 1), LL(s.x + 2, s.y - 1), L(s.x, s.y - 2);         

        if (inside(n, UL) && seen.find(UL) == seen.end()) {
            q.push(UL);
            seen.insert(UL);
            board[UL.x][UL.y] = s;
            board[UL.x][UL.y].dir = "UL";
        }

        if (inside(n, UR) && seen.find(UR) == seen.end()) {
            q.push(UR);
            seen.insert(UR);
            board[UR.x][UR.y] = s;
            board[UR.x][UR.y].dir = "UR";
        }

        if (inside(n, R) && seen.find(R) == seen.end()) {
            q.push(R);
            seen.insert(R);
            board[R.x][R.y] = s;
            board[R.x][R.y].dir = "R";
        }

        if (inside(n, LR) && seen.find(LR) == seen.end()) {
            q.push(LR);
            seen.insert(LR);
            board[LR.x][LR.y] = s;
            board[LR.x][LR.y].dir = "LR";
        }

        if (inside(n, LL) && seen.find(LL) == seen.end()) {
            q.push(LL);
            seen.insert(LL);
            board[LL.x][LL.y] = s;
            board[LL.x][LL.y].dir = "LL";
        }

        if (inside(n, L) && seen.find(L) == seen.end()) {
            q.push(L);
            seen.insert(L);
            board[L.x][L.y] = s;
            board[L.x][L.y].dir = "L";
        }

        if (UL == end) {
            board[end.x][end.y] = s;
            board[end.x][end.y].dir = "UL";
            break;
        }
        if (UR == end) {
            board[end.x][end.y] = s;
            board[end.x][end.y].dir = "UR";
            break;
        }
        if (R == end) {
            board[end.x][end.y] = s;
            board[end.x][end.y].dir = "R";
            break;
        }
        if (LR == end) {
            board[end.x][end.y] = s;
            board[end.x][end.y].dir = "LR";
            break;
        }
        if (LL == end) {
            board[end.x][end.y] = s;
            board[end.x][end.y].dir = "LL";
            break;
        }
        if (L == end) {
            board[end.x][end.y] = s;
            board[end.x][end.y].dir = "L";
            break;
        }
    }

    Point temp = end;
    std::vector<std::string> res;
    while (!(board[temp.x][temp.y] == temp)) {
        res.push_back(board[temp.x][temp.y].dir);
        temp = board[temp.x][temp.y];
    }

    if (res.size() == 0) {
        std::cout << "Impossible" << '\n';
        return ;
    }

    std::cout << res.size() << '\n';
    for (int i = res.size() - 1; i >= 0; --i) {
        std::cout << res[i] << ' ';
    }

    std::cout << '\n';
}

int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(NULL);

    int n;
    std::cin >> n;

    Point start, end;
    std::cin >> start.x >> start.y >> end.x >> end.y;

    solve(n, start, end);
}