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

public class Solution {
    
    static class Pos {
        int i, j;
        int state;  //0-undiscovered, 1- discovered, 2-done
        
        Pos(int i, int j) {
            this.i = i;
            this.j = j;
        }
        public boolean equals(Object o) {
            Pos p = (Pos) o;
            return this.i == p.i && this.j == p.j;
        }
        
        public int hashCode() {
            return 31*i + j;
        }
        
        ///UL, UR, R, LR, LL, L
        Map<String, Pos> getAdj(int n) {
            Map<String, Pos> adj = new LinkedHashMap();
            //(i-2,j-1) , (i-2,j+1), (i, j + 2), (i+2,j+1), (i+2,j-1), (i,j-2)
            if (i >= 2) {
                if (j >= 1) {
                    adj.put("UL", new Pos(i-2,j-1));
                }
                if (j<n-1) {
                    adj.put("UR", new Pos(i-2, j+1));
                }                
            }
            if (j<n-2) {
                adj.put("R", new Pos(i, j+2));
            }
            if (i<n-2) {
                if (j < n-1) {
                    adj.put("LR", new Pos(i+2, j+1));
                }
                if (j >= 1) {
                    adj.put("LL", new Pos(i+2, j-1));
                }                
            }
            if (j >= 2) {
                adj.put("L", new Pos(i, j-2));
            }
            return adj;
        }
    }
       
    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.
        Pos start = new Pos(i_start, j_start);
        Pos end = new Pos(i_end, j_end);
        List<String> best = null;
        //solve(n, start, end, new LinkedHashSet(), new ArrayList());
        //Map<Pos, Pos> parents = new HashMap();
        bfs(n, start, end);
    }
    
    static class Transition {
        Pos p;
        String direction;
        Transition(Pos p, String d) {
            this.p = p;
            this.direction = d;
        }
    }
    
    static void bfs(int n, Pos start, Pos end) {        
        Map<Pos, Transition> parents = new HashMap();
        parents.put(start, null);
        LinkedList<Pos> queue = new LinkedList();
        Set<Pos> visited = new HashSet();
        queue.add(start);
        visited.add(start);
        
        while (!queue.isEmpty()) {
            Pos p = queue.removeFirst();
            Map<String,Pos> adj = p.getAdj(n);
            //boolean ok = false;
            for (Map.Entry<String,Pos> entry : adj.entrySet()) {
                String dir = entry.getKey();
                Pos adjPos = entry.getValue();
                if (!visited.contains(adjPos)) {
                    parents.put(adjPos, new Transition(p, dir));
                    if (end.equals(adjPos)) {
                        printSolution(adjPos, parents);
                        return;
                    }
                    //ok = true;
                    visited.add(adjPos);
                    queue.add(adjPos);
                }
            }
            p.state = 2;
        }
                              
        System.out.println("Impossible");        
    }
                              
    static void printSolution(Pos end, Map<Pos, Transition> parents) {
        LinkedList<String> path = new LinkedList();
        while (parents.get(end) != null) {
            path.addFirst(parents.get(end).direction);
            end = parents.get(end).p;
        }
        StringBuilder sb = new StringBuilder();
        for (String p : path) {
            sb.append(p).append(" ");
        }
        System.out.println(path.size());
        System.out.println(sb.toString().trim());
    }                              
    
    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();
    }
}