#include <bits/stdc++.h>
template<class T> inline bool chmin(T&a, T b){if(a > b){a = b; return true;}else{return false;}}
template<class T> inline bool chmax(T&a, T b){if(a < b){a = b; return true;}else{return false;}}
#define ll long long
#define double long double
#define rep(i,n) for(int i=0;i<(n);i++)
#define REP(i,n) for(int i=1;i<=(n);i++)
#define mod (ll)(1e9+7)
#define inf (ll)(3e18+7)
#define eps (double)(1e-9)
#define pi (double) acos(-1)
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()
using namespace std;

#define P pair<ll, ll>

random_device rnd;
mt19937 mt(rnd());
uniform_int_distribution<> rand100(0, mod);
int rand_int(int l, int u){
    return l + rand100(mt) % (u-l+1);
}

struct edge{
    ll to, cost, cnt;
};
using Graph = vector<vector<edge>>;
Graph G(30*30);
vector<ll> prv;
vector<ll> dis;

vector<string> anss;

void dijkstra(int s){
    int N = G.size();
    priority_queue<P, vector<P>, greater<P>> pq; 
    dis.resize(N);
    prv.resize(N);
    rep(i, N)dis[i] = inf;
  	rep(i, N)prv[i] = -1;
  	dis[s] = 0;
    pq.emplace(dis[s], s);
    while(!pq.empty()){
        P p = pq.top();
        pq.pop();
        int v = p.second;
        if(dis[v] < p.first)continue;
        for(auto &e : G[v]){
            ll now = e.cost;
            if(e.cnt != -1)now = (e.cost + e.cnt - 1) / e.cnt;
            if(dis[e.to] > dis[v] + now){
                dis[e.to] = dis[v] + now;
                prv[e.to] = v; 
                pq.emplace(dis[e.to], e.to);
            }
        }
    }
}

map<pair<int, int>, string> mp;
string get_path(int t) {
    vector<int> path;
    for (int cur = t; cur != -1; cur = prv[cur]) {
        path.push_back(cur);
    }
    reverse(path.begin(), path.end());
    string ret;
    REP(i, path.size()-1){
        if(path[i]-path[i-1] == 1)ret += "R";
        else if(path[i]-path[i-1] == -1)ret += "L";
        else if(path[i]-path[i-1] == 30)ret += "D";
        else if(path[i]-path[i-1] == -30)ret += "U";
        else ret += mp[{path[i-1], path[i]}];
    }
    return ret;
}

int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};

void solve(){
    rep(x, 30)rep(y, 30){
        rep(i, 4){
            int nx = x + dx[i];
            int ny = y + dy[i];
            if(nx < 0 || nx >= 30 || ny < 0 || ny >= 30)continue;
            G[x*30+y].push_back({nx*30+ny, 3000, -1});
        }
    }
    rep(_, 1000){
        int si, sj, ti, tj;
        cin >> si >> sj >> ti >> tj;
        dijkstra(si*30+sj);
        string path = get_path(ti*30+tj);
        cout << get_path(ti*30+tj) << endl;

        //anss.push_back(get_path(ti*30+tj));

        int ans;
        cin >> ans;

        //double now; cin >> now;

        int x = si, y = sj;
        int s = path.size();
        rep(i, path.size()){
            int nx = x, ny = y;
            if(path[i] == 'U')nx--;
            if(path[i] == 'D')nx++;
            if(path[i] == 'L')ny--;
            if(path[i] == 'R')ny++;
            int idx = -1;
            rep(j, G[x*30+y].size())if(G[x*30+y][j].to == nx*30+ny)idx = j;
            if(G[x*30+y][idx].cnt == -1){
                G[x*30+y][idx].cnt = 0;
                G[x*30+y][idx].cost = 0;
            }
            assert(s <= 60);
            G[x*30+y][idx].cnt += max(0, 3601 - s*s);
            G[x*30+y][idx].cost += ans/s * max(0, 3601 - s*s);
          	x = nx; y = ny;
        }
    }
}

int main(){
    solve();  
    //for(auto s : anss)cout << s << endl;  
}
#include <bits/stdc++.h>
using namespace std;

//---------------- 定数 ----------------

// [X_MIN, X_MAX], [Y_MIN, Y_MAX]
#define X_MIN 0
#define X_MAX 29 
#define Y_MIN 0
#define Y_MAX 29

#define QUERY 1000


// -------- util function --------

int rand_int(){
	static unsigned long long x=123456789, y=362436069, z=521288629, w=88675123; 
	unsigned long long t = (x^(x << 11));
	x=y; y=z; z=w;
	return (w=(w^(w>>19))^(t^(t>>8)));
}

// -------------------------------


// 座標(y, x)を扱うクラス
struct Point{
	int x, y;

	//Point(int y, int x): x(x), y(y);
};

struct Query{
	Point start, end;
	string ans;

	// クエリを開始する処理
	void init(){
		cin >> start.y >> start.x >> end.y >> end.x;
	}

	// クエリの答えを出力する処理
	void submit(){
		int point;
		cout << ans << endl;
		cin >> point;
		return;
	}

	void solve(){
		Point now = start;

		int flag = -1;
		if(flag == -1) flag = rand_int() % 2;
		while(now.y != end.y || now.x != end.x){
			if(now.y == end.y) flag = 1;
			if(now.x == end.x) flag = 0;

			if(flag == 0){
				if(now.y < end.y){
					ans.push_back('D');
					now.y++;
				}else{
					ans.push_back('U');
					now.y--;
				}
			}else{
				if(now.x < end.x){
					ans.push_back('R');
					now.x++;
				}else{
					ans.push_back('L');
					now.x--;
				}
			}
		}
	}
};

int main(){
	for(int q = 0;q < QUERY;q++){
		Query query;
		query.init();
		query.solve();
		query.submit();
	}
	return 0;
}
