#include<iostream>
#include<math.h>
#include<time.h>
#include<algorithm>
#include<random>
#include<vector>
#include<string>
using namespace std;

int num_cand = 3000;

mt19937 engine(time(0));

vector<vector<double>> x_path(100, vector<double>(100, 5000.0));  //(30, 29)
vector<vector<double>> y_path(100, vector<double>(100, 5000.0));  //(29, 30)

string basic_path(int j_def, int i_def){
    string result;
    if(j_def > 0){
        for(int j = 0; j < j_def; j++){
            result += "R";
        }
    }else{
        for(int j = 0; j < - j_def; j++){
            result += "L";
        }            
    }
 
    if(i_def > 0){
        for(int i = 0; i < i_def; i++){
            result += "D";
        }
    }else{
        for(int i = 0; i < - i_def; i++){
            result += "U";
        }            
    }

    return(result);
}

class path{
    public:
        double expected_cost;
        string movement;
        void assign_cost(int i_now, int j_now);
        void modify_expectation(int i_now, int j_now, int real_cost);
};

void path::assign_cost(int i_now, int j_now){
    int N = movement.length();
    for(int l = 0; l < N; l++){
        if(movement.at(l) == 'D'){
            expected_cost += y_path.at(i_now).at(j_now);
            i_now += 1;
        }else if(movement.at(l) == 'U'){
            expected_cost += y_path.at(i_now-1).at(j_now);
            i_now -= 1;
        }else if(movement.at(l) == 'R'){
            expected_cost += x_path.at(i_now).at(j_now);
            j_now += 1;
        }else{
            expected_cost += x_path.at(i_now).at(j_now-1);
            j_now -= 1;  
        }
    }
}

void path::modify_expectation(int i_now, int j_now, int real_cost){
    int N = movement.length();
    double new_expectation = real_cost / (double)N;
    for(int l = 0; l < N; l++){
        if(movement.at(l) == 'D'){
            y_path.at(i_now).at(j_now) = new_expectation;
            i_now += 1;
        }else if(movement.at(l) == 'U'){
            y_path.at(i_now-1).at(j_now) = new_expectation;
            i_now -= 1;
        }else if(movement.at(l) == 'R'){
            x_path.at(i_now).at(j_now) = new_expectation;
            j_now += 1;
        }else{
            x_path.at(i_now).at(j_now-1) = new_expectation;
            j_now -= 1;  
        }
    }
}

int main(){
    for(int k = 0; k < 1000; k++){
        int sy, sx, ty, tx;
        cin >> sy >> sx >> ty >> tx;

        int dx = tx - sx;
        int dy = ty - sy;

        string basics = basic_path(dx, dy);

        vector<path> paths(num_cand);
        double min_cost = pow(10, 9);
        int min_cost_id = -1;
        for(int i = 0; i < num_cand; i++){
            shuffle(basics.begin(), basics.end(), engine);
            paths.at(i).movement = basics;
            paths.at(i).assign_cost(sy, sx);

            if(paths.at(i).expected_cost < min_cost){
                min_cost = paths.at(i).expected_cost;
                min_cost_id = i;
            }
        }

        cout << paths.at(min_cost_id).movement << endl;

        int real_cost;
        cin >> real_cost;

        paths.at(min_cost_id).modify_expectation(sy, sx, real_cost);
    }
}
#include<bits/stdc++.h>
using namespace std;

int main(){
    for(int i=0;i<1000;i++){
        int si,sj,ti,tj;
        cin>>si>>sj>>ti>>tj;
        int difx=si-ti;
        int dify=sj-tj;

        if(difx>0){
            for(int i=0;i<difx;i++){
                cout<<'U';
            }
        }else{
            for(int i=0;i<abs(difx);i++){
                cout<<'D';
            }
        }

        if(dify>0){
            for(int i=0;i<dify;i++){
                cout<<'L';
            }
        }else{
            for(int i=0;i<abs(dify);i++){
                cout<<'R';
            }
        }

        cout<<endl;

        long long num;
        cin>>num;
    }
}