#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll,ll> P;
typedef vector<ll> VI;
typedef vector<VI> VVI;
#define REP(i,n) for(ll i=0;i<(n);i++)
#define ALL(v) v.begin(),v.end()
constexpr ll MOD=1000000007;
constexpr ll INF=2e18;

//#define DEBUG

const int n=30;
const int q=1000;
VVI h(n,VI(n-1)), v(n-1,VI(n));
VVI calch(n,VI(n-1,5000)), calcv(n-1,VI(n,5000));
const char dir[3][3]={{' ','U',' '},{'L',' ','R'},{' ','D',' '}};

struct Point{
    int i;
    int j;
    bool operator!=(const Point &other){
        return (i!=other.i||j!=other.j);
    }
};

void debug_init(){
    REP(i,n)REP(j,n-1) cin >> h[i][j];
    REP(i,n-1)REP(j,n) cin >> v[i][j];
}

string routegen(Point s, Point t){
    VVI dp(n,VI(n,INF));
    vector<vector<Point>> pre(n,vector<Point>(n));
    dp[s.i][s.j]=0;
    int di=(s.i<t.i?1:-1), dj=(s.j<t.j?1:-1);
    int ci=(s.i<t.i?0:-1), cj=(s.j<t.j?0:-1);
    for(int i=s.i;i!=t.i+di;i+=di){
        for(int j=s.j;j!=t.j+dj;j+=dj){
            if(i+di>=0&&i+di<n){
                if(dp[i+di][j]>dp[i][j]+calcv[i+ci][j]){
                    dp[i+di][j]=dp[i][j]+calcv[i+ci][j];
                    pre[i+di][j]={i,j};
                }
            }
            if(j+dj>=0&&j+dj<n){
                if(dp[i][j+dj]>dp[i][j]+calch[i][j+cj]){
                    dp[i][j+dj]=dp[i][j]+calch[i][j+cj];
                    pre[i][j+dj]={i,j};
                }
            }
        }
    }
    string ret;
    Point now=t;
    while(now!=s){
        Point p=pre[now.i][now.j];
        ret+=dir[now.i-p.i+1][now.j-p.j+1];
        now=p;
    }
    reverse(ALL(ret));
    return ret;
}

int main(){
    #ifdef DEBUG
    debug_init();
    #endif
    Point s, t;
    int a, x; double e;
    REP(qnum,q){
        cin >> s.i >> s.j >> t.i >> t.j;
        #ifdef DEBUG
        cin >> a >> e;
        #endif
        string ans=routegen(s,t);
        cout << ans << endl;
        #ifndef DEBUG
        cin >> x;
        Point now=s;
        int ave=10/ans.size();
        for(char c:ans){
            if(c=='U'){
                calcv[now.i-1][now.j]=ave;
                now.i--;
            }
            else if(c=='D'){
                calcv[now.i][now.j]=ave;
                now.i++;
            }
            else if(c=='L'){
                calch[now.i][now.j-1]=ave;
                now.j--;
            }
            else{
                calch[now.i][now.j]=ave;
                now.j++;
            }
        }
        #endif
    }
}
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <queue>
using namespace std;
typedef long long ll;

struct edge{
    int to,cost;
    edge(int a,int b):to(a),cost(b) {}
};
vector<vector<edge>> G(900);
vector<int> d(900);
vector<int> prevs(900);
const int INF = 1e9;
string res = "";
int sx,sy,gx,gy;

int heuristics(int x,int y){
    return 1000*(abs(x-gx)+abs(y-gy));
}

void discover(int s){
        for (int i = 0; i < 900;i++){
            d[i] = INF;
            prevs[i] = -1;
        }
        priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>> que;
        d[s] = 0;
        que.push({0,s});
        while(!que.empty()){
            pair<int,int> p = que.top();que.pop();
            int v = p.second;
            if (d[v] < p.first) continue;
            for (int i=0;i < G[v].size();i++){
                edge e=G[v][i];
                if (d[e.to] > d[v] + e.cost){
                    d[e.to] = d[v] + e.cost;
                    prevs[e.to] = v;
                    que.push({d[e.to],e.to});
                }
            }
        }
    }

    vector<int> get_path(int t){
        vector<int> path;

        for (; t != -1;t=prevs[t]) {
            path.push_back(t);
            //cerr <<"insert " << t << "\n";
            //cerr << "next " << prevs[t] << "\n";
        }
        reverse(path.begin(),path.end());
        int len = path.size();
        res = "";
        for (int i = 1; i < len;i++){
            int now = path[i], pre = path[i-1];
            if (pre%30 + 1 == now%30) res.push_back('R');
            else if (pre%30 -1 == now%30) res.push_back('L');
            else if (pre/30 + 1 == now/30) res.push_back('D');
            else if (pre/30 - 1 == now/30 ) res.push_back('U');
        }
        return path;
    }

    void edgeupdate(int costsum,const vector<int> &path){
        int len = res.size();
        int cost = costsum/len;
        for (int i=1;i < path.size();i++){
            for (auto &e :G[path[i-1]]){
                if (e.to == path[i]) e.cost = cost;
            }
        }
    }


int main(){
    for (int i = 0;i < 30;i++){
        for (int j = 0; j < 30;j++){
            if (i == 29 && j == 29) continue;
            else if (i == 29){
                G[i*30+j].push_back(edge(i*30+j+1,9000));
                G[i*30+j+1].push_back(edge(i*30+j,9000));
            }
            else if (j == 29){
                G[i*30+j].push_back(edge((i+1)*30+j,9000));
                G[(i+1)*30+j].push_back(edge(i*30+j,9000));
            }
            else{
                G[i*30+j].push_back(edge(i*30+j+1,9000));
                G[i*30+j+1].push_back(edge(i*30+j,9000));
                G[i*30+j].push_back(edge((i+1)*30+j,9000));
                G[(i+1)*30+j].push_back(edge(i*30+j,9000));
            }
        }
    }

    for (int q = 0; q < 1000;q++){
        
        cin >> sx >> sy >> gx >> gy;
        int score = 0;
        //cerr << "(sx,sy),(gx,gy) = " << "(" << sx << "," << sy << ")" << " (" << gx << "," << gy << ")" << "\n";
        discover(sx*30+sy);
        //cerr << "x,y" <<  " " << sx*30+sy << " " << gx*30+gy << "\n";
        //cerr << d[gx*30 + gy] << "\n";
        //cerr << d[sx*30+sy+1] << "\n";
        vector<int> ps = get_path(gx*30+gy);
        //cerr << "res :" << res << "\n";
        //for (auto v:ps){
        //    cerr << v << " "; 
        //}
        //cerr << "\n";
        cout << res << endl;
        //fflush(stdout);
        cin >> score;
        edgeupdate(score,ps);
    }
    return 0;
}