#include<bits/stdc++.h>
using namespace std;
using lli = long long;
#define rep(i,n) for(int i=0;i<n;i++)
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
template<class T>
ostream &operator<<(ostream &os, const vector<T> &x){
    os << "{";
    for(size_t i = 0; i < x.size(); i++){
        if(i < x.size()-1) os << x[i] << ", ";
        else os << x[i];
    }
    os << "}";
    return os;
}

int main(void){
    int b;
    rep(k, 1000){
        int sx, sy, tx, ty;
        cin >> sx >> sy >> tx >> ty;
        int dx = tx-sx;
        int dy = ty-sy;
        char u, v;
        u = 'D', v = 'R';
        if(dx < 0) u = 'U', dx = -dx;
        if(dy < 0) v = 'L', dy = -dy;
        rep(i, dx) cout << u;
        rep(i, dy) cout << v;
        cout << endl;
        cout << flush;
        cin >> b;
    }
    return 0;
}

#include <algorithm>
#include <chrono>
#include <cmath>
#include <iostream>
#include <queue>
#include <string>
#include <vector>

using namespace std;

//------------------------------------------------------------------------------
class Timer {
public:
	explicit Timer()
		: mStart(chrono::system_clock::now())
	{}
	void start() { mStart = chrono::system_clock::now(); }
	double msec() const {
		auto t = chrono::system_clock::now();
		return 1e-3 * chrono::duration_cast<std::chrono::microseconds>(t - mStart).count();
	}
private:
	chrono::system_clock::time_point mStart;
};

//------------------------------------------------------------------------------
class XorShift {
public:
	using result_type = uint32_t;
	explicit XorShift(result_type seed){ init(seed); }
	void init(result_type s){
		x = 1812433253U * (s ^ (s >> 30));
		y = 1812433253U * (x ^ (x >> 30)) + 1;
		z = 1812433253U * (y ^ (y >> 30)) + 2;
		w = 1812433253U * (z ^ (z >> 30)) + 3;
	}
	static constexpr result_type min() { return numeric_limits<result_type>::min(); }
	static constexpr result_type max() { return numeric_limits<result_type>::max(); }
	result_type operator() () {
		result_type t = x ^ (x << 11);
		x = y; y = z; z = w;
		return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
	}
private:
	result_type x;
	result_type y;
	result_type z;
	result_type w;
};

void randomPlay(){
    for(int _=0;_<1000;_++){
        int x1, y1, x2, y2; cin >> x1 >> y1 >> x2 >> y2;
        string s;
        if(x1 < x2) s.append(string(x2-x1, 'D'));
        if(x1 > x2) s.append(string(x1-x2, 'U'));
        if(y1 < y2) s.append(string(y2-y1, 'R'));
        if(y1 > y2) s.append(string(y1-y2, 'L'));
        cout << s << endl;
        int score; cin >> score;
    }
}

int main(){
    randomPlay();
}