import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;

public class Solution {
    private static boolean[] visited;
    private static int[] edgeTo;
    private static int[] distTo;
    private static int n;
    
    static 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.        
        int v = n * n;
        Solution.n = n;
        int start = mapper(i_start, j_start);
        int end = mapper(i_end, j_end);
        
        Graph g = new Graph(v);
        visited = new boolean[v];
        connectEdge(i_start, j_start, g);
        
        visited = new boolean[v];
        edgeTo = new int[v];
        distTo = new int[v];
        bfs(g, start);
        
        // hasPathTo
        if(end == -1 || !visited[end]) {
          System.out.println("Impossible");  
        } else {
            List<Integer> path = new ArrayList<Integer>();
            int x;
            for (x = end; distTo[x] != 0; x = edgeTo[x]) {
                path.add(x);
            }
            path.add(x);
            int i = i_start, j = j_start;
            System.out.println(path.size() - 1);
            for(int idx = path.size() - 1; idx >= 0; idx--) {
                String mv = mapMove(path.get(idx), i, j);
                if(mv == null) continue;
                if(mv.equals("UL")) {
                    i -= 2;
                    j --;
                }
                if(mv.equals("UR")) {
                    i -=2 ;
                    j ++;
                }
                if(mv.equals("R")) {
                    j += 2;
                }
                if(mv.equals("LR")) {
                    i +=2 ;
                    j ++;
                }
                if(mv.equals("LL")) {
                    i +=2 ;
                    j --;
                }
                if(mv.equals("R")) {
                    j -= 2;
                }
                System.out.print(mv + " ");
                
            }
        }
    }
    
    private static String mapMove(int pos, int i, int j) {
        if(mapper(i - 2, j - 1) == pos) return "UL";
        if(mapper(i - 2, j + 1) == pos) return "UR";
        if(mapper(i, j + 2) == pos) return "R";
        if(mapper(i + 2, j + 1) == pos) return "LR";
        if(mapper(i + 2, j - 1) == pos) return "LL";
        if(mapper(i, j - 2) == pos) return "L";
        
        return null;
    }
    
    // row major order
    private static int mapper(int i, int j) {
        if(i < 0 || i > (n - 1)) 
            return -1;
        if(j < 0 || j > (n - 1)) 
            return -1;
        return (i * n) + j; 
    }
    
    private static void connectEdge(int i, int j, Graph g) {
        int c = mapper(i, j);
        if(c == -1 || visited[c]) return;
        
        visited[c] = true;
        int ul = mapper(i - 2, j - 1);
        if(ul != -1) g.addEdge(c, ul);
        connectEdge(i - 2, j - 1, g);
        
        int ur = mapper(i - 2, j + 1);
        if(ur != -1) g.addEdge(c, ur);
        connectEdge(i - 2, j + 1, g);
        
        int r = mapper(i, j + 2);
        if(r != -1) g.addEdge(c, r);
        connectEdge(i, j + 2, g);
        
        int lr = mapper(i + 2, j + 1);
        if(lr != -1) g.addEdge(c, lr);
        connectEdge(i + 2, j + 1, g);
        
        int ll = mapper(i + 2, j - 1);
        if(ll != -1) g.addEdge(c, ll);
        connectEdge(i + 2, j - 1, g);
        
        int l = mapper(i, j - 2);
        if(l != -1) g.addEdge(c, l);
        connectEdge(i, j - 2, g);
    }
    
    private static void bfs(Graph G, int s) {
        Queue<Integer> q = new LinkedList<>();
        
        for (int v = 0; v < G.V(); v++)
            distTo[v] = Integer.MAX_VALUE;
        
        distTo[s] = 0;
        visited[s] = true;
        q.add(s);
        while (!q.isEmpty()) {
            int v = q.remove();
            for (int w : G.adj(v)) {
                if (!visited[w]) {
                    edgeTo[w] = v;
                    distTo[w] = distTo[v] + 1;
                    visited[w] = true;
                    q.add(w);
                }
            }
        }
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int i_start = in.nextInt();
        int j_start = in.nextInt();
        int i_end = in.nextInt();
        int j_end = in.nextInt();
        printShortestPath(n, i_start, j_start, i_end, j_end);
        in.close();
    }
    
    private static class Graph {
        private final int v;
        private List<Integer>[] adj;
        
        public Graph(int v) {
            this.v = v;
            this.adj = (ArrayList<Integer>[]) new ArrayList[v];
            for(int i = 0; i < v; i++) {
                adj[i] = new ArrayList<Integer>(); 
            }
        }
        
        public void addEdge(int v, int w) {
            adj[v].add(w);
        }

        public Iterable<Integer> adj(int v) {
            return adj[v];
        }
        
        public int V() {
            return this.v;
        }
    }
}