#include <bits/stdc++.h>
using namespace std;

#define uint uint32_t
#define long int64_t
#define ulong uint64_t
#define quit return 0
#define logg(a) cerr << #a << ": " << a << ", "
#define logan(a) cerr << #a << ": " << a << '\n'
#define timeme cerr << 1.0*clock()/CLOCKS_PER_SEC << '\n'
#define iotie ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr); cerr.tie(nullptr);

#define forn(a, b) for(auto a = 0; a < (b); ++a)
#define rforn(a, b) for(auto a = (b); a >= 0; --a)
#define form(a, b, c) for(auto a = (b); a < (c); ++a)
#define pb push_back
#define mp make_pair
#define mt make_tuple

#define bp begin()
#define ep end()
#define be(a) (a).bp, (a).ep
#define rbp rbegin()
#define rep rend()
#define rbe(a) (a).rbp, (a).rep
#define srta(a) sort(be(a))
#define suma(a) accumulate(be(a), 0)
#define prefs(a, b) partial_sum(be(a), (b).bp)
#define cnta(a, b) count(be(a), b)
#define fore(a, b) for_each(be(a), (b))
#define maxa(a) max_element(be(a))
#define mina(a) min_element(be(a))
#define reva(a) reverse(be(a))

template<typename T, typename U>
void operator+= (vector<T>& a, const U& b){
	a.pb(T(b));
}

template<typename T, typename U>
void operator-= (vector<T>& a, const U& b){
	a.erase(a.bp+b);
}


template<typename T>
struct in {
	T x;
	in () : x() { cin >> x; }
	in (const T& x) : x(x) {}
	in (T&& x) : x(x) {}
	operator T& () { return x; }
	operator const T& () const { return x; }
	auto operator[](size_t b) { return x[b]; }
	auto operator[](size_t b) const { return x[b]; }
	auto begin() { return x.begin(); }
	auto end() { return x.end(); }
	auto begin() const { return x.begin(); }
	auto end() const { return x.end(); }
	auto size() const { return x.size(); }
	auto length() { return x.length(); }
	auto length() const { return x.length(); }
};

template<typename T>
struct out {
	T x;
	out () : x() {}
	out (const T& x) : x(x) {}
	out (const in<T>& a) : x(a) {}
	out (T&& x) : x(x) {}
	operator T& () { return x; }
	operator const T& () const { return x; }
	auto operator[](size_t b) { return x[b]; }
	auto operator[](size_t b) const { return x[b]; }
	~out() { cout << x << ' '; }
	auto begin() { return x.begin(); }
	auto end() { return x.end(); }
	auto begin() const { return x.begin(); }
	auto end() const { return x.end(); }
	auto size() const { return x.size(); }
	auto length() { return x.length(); }
	auto length() const { return x.length(); }
};

typedef in<int> iint;
typedef in<long> ilong;
typedef out<int> oint;
typedef out<long> olong;
typedef in<string> istr;
typedef out<string> ostr;

typedef pair<int, int> pii;
typedef pair<long, long> pll;

typedef pair<iint, iint> ipii;
typedef pair<ilong, ilong> ipll;
typedef pair<oint, oint> opii;
typedef pair<olong, olong> opll;

typedef vector<int> vi;
typedef vector<long> vl;
typedef vector<iint> ivi;
typedef vector<ilong> ivl;
typedef vector<oint> ovi;
typedef vector<olong> ovl;

typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef vector<ipii> ivpii;
typedef vector<ipll> ivpll;

typedef vector<bool> vb;

typedef vector<vi> vvi;
typedef vector<vl> vvl;

typedef vector<vpii> vvpii;
typedef vector<vpll> vvpll;

typedef set<int> si;
typedef set<pii> spii;
typedef set<pll> spll;

typedef queue<int> qi;
typedef queue<long> ql;
typedef queue<pii> qpii;
typedef queue<pll> qpll;

typedef stack<int> sti;
typedef stack<long> stl;
typedef stack<pii> stpii;
typedef stack<pll> stpll;

template<typename T>
struct rr_{
	struct valit{
		T val;
		const int order;
		T operator* () const { return val; }
		T operator* () { return val; }
		valit& operator++ () {
			if(order > 0) ++val;
			else --val;
			return *this;
		}
		bool operator != (const valit& other) const {
			return val != other.val;
		}
	};

	const valit l, r;
	valit begin() { return l; }
	valit end() { return r; }
};

template<typename T, typename U>
rr_<T> rr(T a, U b){
	return (a < b ? rr_<T>{{a, 1}, {b, 1}} : rr_<T>{{a, -1}, {b, -1}});
};

template<typename T>
T gcd(T a, T b) {
	T t;
	while (a) { t = a; a = b % a; b = t; }
	return b;
}

//TEMPLATE IS NOW OVER!
//HAVE FUN!!!

int main(){
	iotie;
	
	iint n;

	iint sy, sx, ey, ex;

	if(sy%2 != ey%2){
		cout << "Impossible\n";
		return 0;
	}

	int diffy = (abs(sy-ey))/2;
	int diffx = abs(sx - ex);

	diffx -= diffy;
	if(diffx < 0 || diffx%2){
		cout << "Impossible\n";
		return 0;
	}

	int num = diffy + diffx/2;

	(oint)num;
	cout << '\n';

	bool left = ex < sx;
	bool up = ey < sx;
	for(auto i : rr(0, diffy)){
		if(left && up) cout << "UL ";
		if(left && !up) cout << "LL ";
		if(!left && up) cout << "UR ";
		if(!left && !up) cout << "LR ";
	}

	for(auto i : rr(0, diffx/2)){
		if(left) cout << "L ";
		if(!left) cout << "R ";
	}
	cout << '\n';

}