#include<bits/stdc++.h>
using namespace std;

int h[30][29], v[29][30], hc[30][29], vc[29][30];
int si, sj, ti, tj, prev_si, prev_sj, prev_ti, prev_tj;
int prev_result;
int i=0, j=0;

int border=3;
int repeat_count=1000;

string query(int si, int sj, int ti, int tj){
 string path;
 while(si!=ti || sj!=tj){
  if(si==ti){
   if(sj<tj){
    path=path+"R";
    sj++;
   }
   else{
    path=path+"L";
    sj--;
   }
  }
  else if(sj==tj){
   if(si<ti){
    path=path+"D";
    si++;
   }
   else{
    path=path+"U";
    si--;
   }
  }
  //左上
  else if(si<ti && sj<tj){
   if(hc[si][sj]<border || vc[si][sj]<border){
    if(hc[si][sj]<vc[si][sj]){
     path=path+"R";
     sj++;
    }
    else{
     path=path+"D";
     si++;
    }
   }
   else if(h[si][sj]<v[si][sj]){
    path=path+"R";
    sj++;
   }
   else{
    path=path+"D";
    si++;
   }
  }
  //左下
  else if(si>ti && sj<tj){
   if(hc[si][sj]<border || vc[si-1][sj]<border){
    if(hc[si][sj]<vc[si-1][sj]){
     path=path+"R";
     sj++;
    }
    else{
     path=path+"U";
     si--;
    }
   }
   else if(h[si][sj]<v[si-1][sj]){
    path=path+"R";
    sj++;
   }
   else{
    path=path+"U";
    si--;
   }
  }
  //右下
  else if(si>ti&& sj>tj){
   if(hc[si][sj-1]<border || vc[si-1][sj]<border){
    if(hc[si][sj-1]<vc[si-1][sj]){
     path=path+"L";
     sj--;
    }
    else{
     path=path+"U";
     si--;
    }
   }
   else if(h[si][sj-1]<v[si-1][sj]){
    path=path+"L";
    sj--;
   }
   else{
    path=path+"U";
    si--;
   }
  }
  //右上
  else{
   if(hc[si][sj-1]<border || vc[si][sj]<border){
    if(hc[si][sj-1]<vc[si][sj]){
     path=path+"L";
     sj--;
    }
    else{
     path=path+"D";
     si++;
    }
   }
   else if(h[si][sj-1]<v[si][sj]){
    path=path+"L";
    sj--;
   }
   else{
    path=path+"D";
    si++;
   }
  }
 }
 return path;
}

void sethv(int prev_si, int prev_sj, string prev_path, int prev_result){
 int delta=(int)round(prev_result/prev_path.length())-5000;
 while(prev_path.empty()==0){
  if(prev_path[0]=='R'){
   h[prev_si][prev_sj]=(int)round((h[prev_si][prev_sj]*hc[prev_si][prev_sj]+delta)/(hc[prev_si][prev_sj]+1));
   hc[prev_si][prev_sj]++;
   prev_sj++;
  }
  else if(prev_path[0]=='D'){
   v[prev_si][prev_sj]=(int)round((v[prev_si][prev_sj]*vc[prev_si][prev_sj]+delta)/(vc[prev_si][prev_sj]+1));
   vc[prev_si][prev_sj]++;
   prev_si++;
  }
  else if(prev_path[0]=='L'){
   h[prev_si][prev_sj-1]=(int)round((h[prev_si][prev_sj-1]*hc[prev_si][prev_sj-1]+delta)/(hc[prev_si][prev_sj-1]+1));
   hc[prev_si][prev_sj-1]++;
   prev_sj--;
  }
  else{
   v[prev_si-1][prev_sj]=(int)round((v[prev_si-1][prev_sj]*vc[prev_si-1][prev_sj]+delta)/(vc[prev_si-1][prev_sj]+1));
   vc[prev_si-1][prev_sj]++;
   prev_si--;
  }
  prev_path.erase(0, 1);
 }
}

void read_s_t(){
  cin>>si;
  cin>>sj;
  cin>>ti;
  cin>>tj;
}

void set_prev_s_t(){
 prev_si=si;
 prev_sj=sj;
 prev_ti=ti;
 prev_tj=tj;
}

void read_result(){
 cin>>prev_result;
}

int main(){
 //h初期化
 for(i=0; i<=29; i++){
  for(j=0; j<=28; j++){
   h[i][j]=0;
   hc[i][j]=0;
  }
 }
 //v初期化
 for(i=0; i<=28; i++){
  for(j=0; j<=29; j++){
   v[i][j]=0;
   vc[i][j]=0;
  }
 }

 for(i=0; i<repeat_count; i++){
  read_s_t();
  set_prev_s_t();
  string path=query(si, sj, ti, tj);
  cout<<path<<"\n"<<flush;
  read_result();
  sethv(prev_si, prev_sj, path, prev_result);
 }
 return 0;
}

#include <cstdio>
#include <cassert>
#include <iostream>
#include <algorithm>
#include <queue>
#include <vector>
using namespace std;
#define REP(i, n) for(int i = 0; i < (int)(n); ++i)
typedef long long ll;

const int N = 30;
const int MIN_COST = 1000;
// const int MAX_COST = 9000;

const int nQuery = 1000;
enum {
  D = 0, L, U, R
};
const int DI[4] = {1, 0, -1, 0};
const int DJ[4] = {0, -1, 0, 1};
const char * const OP = "DLUR";

struct Result {
  int dist, num;
  Result(int dist, int num) : dist(dist), num(num) {}
  double average(void) const { return double(dist) / num; }
};

class Edge {
public:
  Edge() {
    // 最低値で初期化しておく
    const double EFF = 140;
    numer = MIN_COST / EFF;
    denom = 1 / EFF;
  }
  void addResult(const Result &r) {
    numer += r.average() / r.num;
    denom += 1.0 / r.num;
    rs.push_back(r);
  }
  double cost(void) const {
    return numer / denom;
  }
private:
  double numer, denom;
  vector<Result> rs;
};
Edge _es[(N-1)*N*2];
Edge *es[N][N][4];

inline void init(void) {
  int t = 0;
  REP(i, N) REP(j, N) {
    if(i+1 < N) {
      es[i][j][D] = &_es[t++];
    }
    if(j+1 < N) {
      es[i][j][R] = &_es[t++];
    }
  }
  REP(i, N) REP(j, N) {
    if(i-1 >= 0) {
      es[i][j][U] = es[i-1][j][D];
    }
    if(j-1 >= 0) {
      es[i][j][L] = es[i][j-1][R];
    }
  }
  assert(t == (N-1)*N*2);
}

inline int query(const vector<int> &ops) {
  for(auto op : ops) {
    printf("%c", OP[op]);
  }
  printf("\n");
  fflush(stdout);
  int res;
  scanf("%d", &res);
  return res;
}

const double INF = 1e9;
double dist[N][N];
int trace[N][N];
struct K {
  int i, j;
  double c;
  K(int i, int j, double c) : i(i), j(j), c(c) {}
};
bool operator>(const K& a, const K& b) {
  return a.c > b.c;
}

int main(void) {
  init();
  REP(iQuery, nQuery) {
    int si, sj, gi, gj;
    scanf("%d%d%d%d", &si, &sj, &gi, &gj);
    { // dijkstra
      REP(i, N) REP(j, N) {
        dist[i][j] = INF;
      }
      priority_queue<K, vector<K>, greater<K> > q;
      q.push(K(si, sj, 0));
      dist[si][sj] = 0;
      while(!q.empty()) {
        K cur = q.top(); q.pop();
        int ci = cur.i;
        int cj = cur.j;
        if(dist[ci][cj] < cur.c) {
          continue;
        }
        if(ci == gi && cj == gj) {
          break;
        }
        REP(d, 4) {
          int ni = ci + DI[d];
          int nj = cj + DJ[d];
          if(ni >= 0 && nj >= 0 && ni < N && nj < N) {
            double c = cur.c + es[ci][cj][d]->cost();
            if(c < dist[ni][nj]) {
              q.push(K(ni, nj, c));
              dist[ni][nj] = c;
              trace[ni][nj] = d;
            }
          }
        }
      }
    }
    vector<int> ops;
    for(int ci = gi, cj = gj; ci != si || cj != sj; ) {
      int op = trace[ci][cj];
      ops.push_back(op);
      ci -= DI[op];
      cj -= DJ[op];
    }
    reverse(ops.begin(), ops.end());
    int res = query(ops);
    {
      int ci = si;
      int cj = sj;
      for(auto op : ops) {
        es[ci][cj][op]->addResult(Result(res, ops.size()));
        ci += DI[op];
        cj += DJ[op];
      }
    }
  }
  return 0;
}
