#include <iomanip>
#include <iostream>
#include <vector>
#include <bitset>
#include <deque>
#include <algorithm>
#include <set>
#include <map>
#include <cstring>
#include <cassert>

#define REP(x,l,u) for(int x = (l);x<=(u);x++)

using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
const ll llmax=9223372036854775807;
const ll llmin=-9223372036854775808;
const int intmin=-2147483648;
const int intmax=2147483647;
const int mod=1e9+7;

ll gcd(ll a,ll b){if(a==0 || b==0) return a+b;else return gcd(b,a%b);}
template<typename A,typename B> inline A fexp(A x,B p){A ans=1;for(;p;p>>=1,x=1LL*x*x%mod)if(p&1)ans=1LL*ans*x%mod;return ans;}
template<typename T> inline void read(T &x){
    x=0;T f=1;char ch;do{ch=getchar();if(ch=='-')f=-1;}while(ch<'0'||ch>'9');do x=x*10+ch-'0',ch=getchar();while(ch<='9'&&ch>='0');x*=f;
}
class ST{
    struct Node{
        int l,r;
        ll sm,bjc,bjj;
        ll min;
        ll max;
        ll oor;
        ll andd;
    };
    vector<ll> A;
    vector<Node> T;
public:
    ST(vector<ll>& AA) {
        A.emplace_back(0);//to make it 1 indexed
        for(int i=0;i<AA.size();i++)
            A.emplace_back(AA[i]);
        T.resize(A.size()<<2);
        build(1,1,(int)A.size()-1);
    }

    ll QuerySum(int l,int r){return querySum(1,l,r);}
    ll QueryOr(int l,int r){return queryOr(1,l,r);}
    ll QueryAnd(int l,int r){return queryAnd(1,l,r);}
    ll QueryMax(int l,int r){return queryMax(1,l,r);}
    ll QueryMin(int l,int r){return queryMin(1,l,r);}
    void   Add(int l,int r,ll x){add(1,l,r,x);}
    void   Mul(int l,int r,ll x){mul(1,l,r,x);}
private:
    void pushup(int i){
        T[i].sm=T[i<<1].sm+T[i<<1|1].sm;
        T[i].min=min(T[i<<1].min,T[i<<1|1].min);
        T[i].max=max(T[i<<1].max,T[i<<1|1].max);
        T[i].oor=(T[i<<1].oor)|(T[i<<1|1].oor);
        T[i].andd=(T[i<<1].andd)&(T[i<<1|1].andd);
    }

    void mul(int i,ll x){
        T[i].sm*=x;T[i].bjc*=x;T[i].bjj*=x;
    }

    void add(int i,ll x){
        T[i].sm+=x*(T[i].r-T[i].l+1);T[i].bjj+=x;
    }

    void pushdown(int i){
        mul(i<<1,T[i].bjc);mul(i<<1|1,T[i].bjc);T[i].bjc=1;
        add(i<<1,T[i].bjj);add(i<<1|1,T[i].bjj);T[i].bjj=0;
    }

    void build(int i,int l,int r){
        T[i].l=l;T[i].r=r;T[i].bjc=1;
        if(l==r){
            T[i].sm=A[l];
            T[i].min=A[l];
            T[i].max=A[l];
            T[i].oor=A[l];
            T[i].andd=A[l];
            return;
        }
        int M=l+r>>1;
        build(i<<1,l,M);build(i<<1|1,M+1,r);
        pushup(i);
    }

    ll querySum(int i,int l,int r){
        if(l<=T[i].l&&T[i].r<=r)return T[i].sm;//
        int M=T[i].l+T[i].r>>1;ll ans=0;
        pushdown(i);
        if(l<=M)ans+=querySum(i<<1,l,r);if(r>M)ans+=querySum(i<<1|1,l,r);
        return ans;
    }
    ll queryOr(int i,int l,int r){
        if(l<=T[i].l&&T[i].r<=r)return T[i].oor;//((T[i].oor-T[i].andd)-(T[i].max-T[i].min));
        int M=T[i].l+T[i].r>>1;ll ans=0;
        pushdown(i);
        if(l<=M)ans=queryOr(i<<1,l,r);if(r>M)ans|=queryOr(i<<1|1,l,r);
        return ans;
    }
    ll queryAnd(int i,int l,int r){
        if(l<=T[i].l&&T[i].r<=r)return T[i].andd;//((T[i].oor-T[i].andd)-(T[i].max-T[i].min));
        int M=T[i].l+T[i].r>>1;ll ans=0;
        pushdown(i);
        bool set=false;
        if(l<=M)ans=queryAnd(i<<1,l,r),set=true;
        if(r>M)ans=set?(ans&queryAnd(i<<1|1,l,r)):queryAnd(i<<1|1,l,r);
        return ans;
    }
    ll queryMax(int i,int l,int r){
        if(l<=T[i].l&&T[i].r<=r)return T[i].max;//((T[i].oor-T[i].andd)-(T[i].max-T[i].min));
        int M=T[i].l+T[i].r>>1;ll ans=llmin;
        pushdown(i);
        if(l<=M)ans=max(ans,queryMax(i<<1,l,r));
        if(r>M)ans=max(ans,queryMax(i<<1|1,l,r));
        return ans;
    }
    ll queryMin(int i,int l,int r){
        if(l<=T[i].l&&T[i].r<=r)return T[i].min;//((T[i].oor-T[i].andd)-(T[i].max-T[i].min));
        int M=T[i].l+T[i].r>>1;ll ans=llmax;
        pushdown(i);
        if(l<=M)ans=min(ans,queryMin(i<<1,l,r));
        if(r>M)ans=min(ans,queryMin(i<<1|1,l,r));
        return ans;
    }

    void add(int i,int l,int r,ll x){
        if(l<=T[i].l&&T[i].r<=r){
            add(i,x);
            return;
        }
        int M=T[i].l+T[i].r>>1;
        pushdown(i);
        if(l<=M)add(i<<1,l,r,x);if(r>M)add(i<<1|1,l,r,x);
        pushup(i);
    }


    void mul(int i,int l,int r,ll x){
        if(l<=T[i].l&&T[i].r<=r){
            mul(i,x);
            return;
        }
        int M=T[i].l+T[i].r>>1;
        pushdown(i);
        if(l<=M)mul(i<<1,l,r,x);if(r>M)mul(i<<1|1,l,r,x);
        pushup(i);
    }

};
struct trip{
    trip(int _len,int _l,int _r):len(_len),l(_l),r(_r){};
    int len;
    int l;
    int r;
};
struct MyClassLessThan
{
    bool operator() (const trip & left, const trip & right)
    {
        return left.len < right.len;
    }
};
bool same2more=false;
bool isPossible(string& st1,string& st2){
    vector<int> dif;
    REP(i,0,st1.size()-1){
        if(st1[i]!=st2[i]){
            dif.emplace_back(i);
        }
    }
    if(dif.size()==0 && same2more)
        return true;
    else if(dif.size()==2 && st1[dif[0]]==st2[dif[1]] && st1[dif[1]]==st2[dif[0]])
        return true;
    else
        return false;
}
int matrix[4][1001];
int dp[1001];

int count1(int xtop,int ytop,int sizex,int sizey){
    int cnt=0;
    REP(x,0,sizex-1){
        REP(y,0,sizey-1){
            if(matrix[ytop-y][xtop-x]==1) cnt++;
        }
    }
    return cnt;
}
int check(int xtop,int ytop,int sizex,int sizey){
    return count1(xtop,ytop,sizex,sizey)>0?1:0;
}
bool board[201][201];
int n;
struct node{
    node(node* pr,pair<int,int> loc){
        parent=pr;
        location=loc;
    }
    node* parent=NULL;
    vector<pair<int,int>> children;
    vector<string> moveNames;
    void addChildren(){
        if(location.first-1>=0 && location.second-2>=0 && !board[location.first-1][location.second-2]) moveNames.emplace_back("UL"), board[location.first-1][location.second-2]=true, children.emplace_back(make_pair(location.first-1,location.second-2));
        if(location.first+1<=n-1 && location.second-2>=0 && !board[location.first+1][location.second-2]) moveNames.emplace_back("UR"), board[location.first+1][location.second-2]=true, children.emplace_back(make_pair(location.first+1,location.second-2));
        if(location.first+2<=n-1 && location.second-0>=0 && !board[location.first+2][location.second-0]) moveNames.emplace_back("R"),  board[location.first+2][location.second-0]=true, children.emplace_back(make_pair(location.first+2,location.second-0));
        if(location.first+1<=n-1 && location.second+2<=n-1 && !board[location.first+1][location.second+2]) moveNames.emplace_back("LR"), board[location.first+1][location.second+2]=true, children.emplace_back(make_pair(location.first+1,location.second+2));
        if(location.first-1>=0 && location.second+2<=n-1 && !board[location.first-1][location.second+2]) moveNames.emplace_back("LL"), board[location.first-1][location.second+2]=true, children.emplace_back(make_pair(location.first-1,location.second+2));
        if(location.first-2>=0 && location.second-0>=0 && !board[location.first-2][location.second-0]) moveNames.emplace_back("L"), board[location.first-2][location.second-0]=true, children.emplace_back(make_pair(location.first-2,location.second-0));
    }
    pair<int,int> location;
};
int main() {
    //ios::sync_with_stdio(0), cin.tie(0);
    bool test= false;
    if(test)
        freopen("/Users/aj/code/HackerRank/input.txt", "r", stdin);
    int xs,ys,xe,ye;
    cin>>n>>ys>>xs>>ye>>xe;
    deque<node*> dq;
    node* root=new node(NULL,pair<int,int>(xs,ys));
    root->addChildren();
    board[xs][ys]=true;
    dq.emplace_back(root);
    bool endfound=false;
    node* thenode=NULL;
    while(dq.size()>0 && !endfound){
        node* curnode=dq.front();
        dq.pop_front();
        for(int i=0;i<curnode->children.size();i++){
            pair<int,int> clocation=curnode->children[i];
            thenode=new node(curnode,clocation);
            thenode->addChildren();
            if(clocation.first==xe && clocation.second==ye){
                endfound=true;
                break;
            }
            dq.emplace_back(thenode);
        }
    }
    if(!endfound)cout<<"Impossible";
    else{
        vector<string> path;
        while(thenode->parent!=NULL){
            node* pr=thenode->parent;
            pair<int,int> curloc=thenode->location;
            for(int c=0;c<pr->children.size();c++){
                pair<int,int> childloc=pr->children[c];
                if(curloc.first==childloc.first && curloc.second==childloc.second){
                    path.emplace_back(pr->moveNames[c]);
                    break;
                }
            }
            thenode=thenode->parent;
        }
        reverse(path.begin(),path.end());
        cout<<path.size()<<endl;
        for(int i=0;i<path.size();i++)cout<<path[i]<<" ";
    }
    return 0;
}