// #pragma GCC optimize("Ofast")

#include <vector>
#include <iostream>
#include <utility>
#include <cmath>
#include <set>
#include <algorithm>
#include <queue>
#include <string>
#include <utility>

using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<ll> vll;
typedef vector<int> vi;
typedef pair<int,int> pii;
// #define int ll
#define fi first
#define se second
#define Sort(a) sort(a.begin(),a.end())
#define rep(i,n) for(int i = 0;i < (n) ; ++i) 
#define REP(i,n) for(int i = 0;i < (n) ; ++i) 
#define MP(a,b) make_pair((a),(b))
#define pb(a) push_back((a))
#define INF LLONG_MAX/4
#define INTINF INT_MAX/2
#define all(x) (x).begin(),(x).end()
#define debug(x) cerr<<#x<<": "<<x<<endl
#define debug_vec(v) cerr<<#v<<":";rep(i,v.size())cerr<<" "<<v[i];cerr<<endl
template<class T> inline bool chmax(T &a, T b){if(a < b){a = b;return true;}return false;}
template<class T> inline bool chmin(T &a, T b){if(a > b){a = b;return true;}return false;}
/*----------------------------------------------------------------*/
inline unsigned long long xor128() {
	static unsigned long long rx = 123456789, ry = 986960440, rz = 738905609, rw = 23140692;
	unsigned long long rt = (rx ^ (rx << 11));
	rx = ry;ry = rz;rz = rw;
	return (rw = (rw ^ (rw >> 19)) ^ (rt ^ (rt >> 8)));
}
inline float rand128(float min = 0, float max = 1){
	return (float)(xor128() % 0xFFFF) / 0xFFFF * (max - min) + min;
}

inline uint64_t rdtsc(){
	uint32_t hi,lo;
	__asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
	return ((uint64_t)lo) | (((uint64_t)hi)<<32);
}
inline double GetSeconds() {
	// return rdtsc()/2.8e9; //Topcoder
	return rdtsc()/3.0e9; // Atcoder
}
double start_time;
const double TL = 1.90;
/*----------------------------------------------------------------*/

/*----------------------------------------------------------------*/
int h[30][29];
int v[29][30];

const int Q = 1000;
const int H = 30;
const int W = 30;

/*----------------------------------------------------------------*/
void input(){
	cerr << "in h" << endl;
	cerr << H << endl;
	cerr << W << endl;
	rep(i,H)rep(j,W-1){
		cin >> h[i][j];
		cerr << h[i][j] << endl;
	}
	cerr << "in v" << endl;
	rep(i,H-1)rep(j,W)cin >> v[i][j];
}   

void solve(){
	cerr << "solve" << endl;
    int si,sj,ti,tj,a;
	rep(q,Q){
        cin >> si >> sj >> ti >> tj;
        if(si > ti)rep(i,si-ti)cout << 'U';
        if(ti > si)rep(i,ti-si)cout << 'D';
        if(sj > tj)rep(i,sj-tj)cout << 'L';
        if(tj > sj)rep(i,tj-sj)cout << 'R';
        cout << endl;
        cin >> a;
    }
}

/*----------------------------------------------------------------*/

int main(){
	cerr << "s" << endl;
	start_time = GetSeconds();
	solve();
}
#include <bits/stdc++.h>
using namespace std;
 
using vi = vector<int>;
#define FOR(i, m, n) for (int i = (m); i < (n); i++)
#define FORR(i, m, n) for (int i = (m); i >= (n); i--)
#define REP(i, n) FOR(i, 0, (n))
#define REPR(i, n) FORR(i, (n) - 1, 0)
#define REP1(i, n) FOR(i, 1, (n) + 1)
#define sz(v) (int)v.size()
const int INF = 1000000001;
 
int main() {
    vi _r{-1, 0, 1, 0};
    vi _c{0, 1, 0, -1};
    vector<char> _d{'U', 'R', 'D', 'L'};
    map<char, int> _q;
    _q['U'] = 0;
    _q['R'] = 1;
    _q['D'] = 2;
    _q['L'] = 3;
    vector<vector<vector<double>>> g(30, vector<vector<double>>(30, vector<double>(4, 5000.0)));
    REP(i, 30) {
        g[i][0][3] = -1.0;
        g[i][29][1] = -1.0;
    }
    REP(i, 30) {
        g[0][i][0] = -1.0;
        g[29][i][2] = -1.0;
    }
    int si, sj, ti, tj;
    double score;
    string ans;

    auto trueSearch = [&]() {
        deque<tuple<int, int, double, string>> q;
        q.emplace_back(si, sj, 0.0, "");
        int r, c;
        double d;
        string m;
        vector<vector<double>> h(30, vector<double>(30, INF));
        h[si][sj] = 0.0;
        while (!q.empty()) {
            tie(r, c, d, m) = q.front();
            q.pop_front();

            if (r == ti and c == tj) {
                ans = m;
                continue;
            }

            REP(i, 4) {
                if (g[r][c][i] < 0.0) continue;
                if (g[r][c][i] + d >= min(h[ti][tj], h[r + _r[i]][c + _c[i]])) continue;
                h[r + _r[i]][c + _c[i]] = g[r][c][i] + d;
                q.emplace_back(r + _r[i], c + _c[i], g[r][c][i] + d, m + _d[i]);
            }
        }
        cout << ans << endl;
        cin >> score;
        return h[ti][tj];
    };

    auto horizontalSearch = [&]() {
        double actual = 0.0;
        int r = si;
        int c = sj;
        while (c < tj) {
            actual += g[r][c][1];
            ans += 'R';
            c++;
        }
        while (c > tj) {
            actual += g[r][c][3];
            ans += 'L';
            c--;
        }
        while (r < ti) {
            actual += g[r][c][2];
            ans += 'D';
            r++;
        }
        while (r > ti) {
            actual += g[r][c][0];
            ans += 'U';
            r--;
        }

        cout << ans << endl;
        cin >> score;
        return actual;
    };

    auto virticalSearch = [&]() {
        double actual = 0.0;
        int r = si;
        int c = sj;
        while (r < ti) {
            actual += g[r][c][2];
            ans += 'D';
            r++;
        }
        while (r > ti) {
            actual += g[r][c][0];
            ans += 'U';
            r--;
        }
        while (c < tj) {
            actual += g[r][c][1];
            ans += 'R';
            c++;
        }
        while (c > tj) {
            actual += g[r][c][3];
            ans += 'L';
            c--;
        }

        cout << ans << endl;
        cin >> score;
        return actual;
    };

    REP(i, 1000) {
        cin >> si >> sj >> ti >> tj;

        ans = "";
        auto actual = (i < 80 ? horizontalSearch() : (i < 160 ? virticalSearch() : trueSearch()));

        int l = sz(ans);
        double coefficient = score / actual;
        coefficient = (1.1 + coefficient) / 2.0;
        int r = si;
        int c = sj;
        REP(i, l) {
            int d = _q[ans[i]];
            g[r][c][d] *= coefficient;
            r += _r[d];
            c += _c[d];
            g[r][c][(d + 2) % 4] *= coefficient;
        }
    }

    return 0;
}

