#include <algorithm>
#include <cassert>
#include <cmath>
#include <iostream>
#include <tuple>
#include <queue>
#include <vector>

// 距離、x座標、y座標
using vertex = std::tuple<int, int, int>;

std::pair<std::string, int> dijkstra(int, int, int, int);
void interact(int);
void modify_distance(const std::string &, int, int, int, int);
int rev(char);

const int dx[]{1, 0, -1, 0}, dy[]{0, 1, 0, -1};
const char dir[]{'D', 'R', 'U', 'L'};
constexpr int INVALID = -1;

// 道の長さ
int d_road[30][30][4];

// 文字を方向のインデックスに変換
int rev(char c)
{
    switch (c)
    {
    case 'D':
        return 0;
    case 'R':
        return 1;
    case 'U':
        return 2;
    case 'L':
        return 3;
    }
    abort();
}

// ダイクストラ法で最短経路を求める
std::pair<std::string, int> dijkstra(int si, int sj, int ti, int tj)
{
    // 距離の初期化
    int distance[30][30];
    for (int i = 0; i < 30; i++)
    {
        for (int j = 0; j < 30; j++)
        {
            distance[i][j] = 1e9;
        }
    }

    // ダイクストラ法
    std::priority_queue<vertex, std::vector<vertex>, std::greater<vertex>> q;
    q.emplace(0, si, sj);
    while (not q.empty())
    {
        auto [d0, x, y] = q.top();
        q.pop();
        if (d0 >= distance[x][y])
        {
            continue;
        }
        distance[x][y] = d0;
        if (x == ti and y == tj)
        {
            break;
        }
        for (int i = 0; i < 4; i++)
        {
            int d = d_road[x][y][i], x_next = x + dx[i], y_next = y + dy[i];
            if (d == INVALID or d0 + d >= distance[x_next][y_next])
            {
                continue;
            }
            q.emplace(d0 + d, x_next, y_next);
        }
    }

    // 経路復元
    std::string res;
    int x = ti, y = tj;
    while (x != si or y != sj)
    {
        for (int i = 0; i < 4; i++)
        {
            int d = d_road[x][y][i], x_prev = x + dx[i], y_prev = y + dy[i];
            if (d == INVALID)
            {
                continue;
            }
            if (distance[x][y] == distance[x_prev][y_prev] + d)
            {
                res.push_back(dir[(i + 2) % 4]);
                x = x_prev;
                y = y_prev;
                break;
            }
            assert(i != 3);
        }
    }
    std::reverse(res.begin(), res.end());
    return {res, distance[ti][tj]};
}

// 道の長さの補正
void modify_distance(const std::string &route, int error, int si, int sj, int query)
{
    const int n = route.size();
    error *= pow(0.9996, query) / n;
    int x = si, y = sj;
    for (int i = 0; i < n; i++)
    {
        int k = rev(route[i]);
        d_road[x][y][k] += error;
        if (d_road[x][y][k] <= 0)
        {
            d_road[x][y][k] = 1;
        }
        x += dx[k];
        y += dy[k];
        k = (k + 2) % 4;
        d_road[x][y][k] += error;
        if (d_road[x][y][k] <= 0)
        {
            d_road[x][y][k] = 1;
        }
    }
}

// クエリに応答
void interact(int query)
{
    int si, sj, ti, tj;
    std::cin >> si >> sj >> ti >> tj;
    auto [route, estimate] = dijkstra(si, sj, ti, tj);
    std::cout << route << std::endl;
    int response;
    std::cin >> response;
    modify_distance(route, response - estimate, si, sj, query);
}

int main()
{
    // 道路の長さの初期値
    for (int i = 0; i < 30; i++)
    {
        for (int j = 0; j < 30; j++)
        {
            for (int k = 0; k < 4; k++)
            {
                int i_next = i + dx[k], j_next = j + dy[k];
                if (i_next < 0 or 30 <= i_next or j_next < 0 or 30 <= j_next)
                {
                    d_road[i][j][k] = INVALID;
                }
                else
                {
                    d_road[i][j][k] = 1;
                }
            }
        }
    }

    // クエリに応答
    for (int query = 0; query < 1000; query++)
    {
        interact(query);
    }
    return 0;
}

#pragma warning(disable:6385)
#define _USE_MATH_DEFINES
#include <cassert>
#include <iostream>
#include <string>
#include <list>
#include <vector>
#include <queue>
#include <algorithm>
#include <climits>
#include <cstring>
#include <cmath>
#include <stack>
#include <iomanip>
#include <tuple>
#include <functional>
#include <cfloat>
#include <map>
#include <chrono>
#include <fstream>
#include <array>
#include <set>
#include <map>

using namespace std;
using namespace chrono;

using ll = long long;
using uint = unsigned int;

#ifdef LOCAL
#define ASSERT_DEBUG
#endif
#ifdef ASSERT_DEBUG
void ASSERT(bool b)
{
	if (!b)
	{
		__debugbreak();
	}
	assert(b);
}
#else
void ASSERT(bool b) {}
#endif

class Point
{
public:
	int x;
	int y;

	Point() { x = 0; y = 0; }
	Point(int x, int y) { this->x = x; this->y = y; }

	Point operator + (const Point& pt) const
	{
		return Point(x + pt.x, y + pt.y);
	}
	Point operator - (const Point& pt) const
	{
		return Point(x - pt.x, y - pt.y);
	}

	bool Equals(const Point& pt) const
	{
		return x == pt.x && y == pt.y;
	}
	bool Equals(int x, int y) const
	{
		return this->x == x && this->y == y;
	}
};


unsigned int xorshift32()
{
	static int s = 7;
	s ^= (s << 13);
	s ^= (s >> 17);
	s ^= (s << 15);
	return s;
}


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

		if (sx < tx)
		{
			for (int j = 0; j < tx - sx; j++)
			{
				cout << "R";
			}
		}
		else if (sx > tx)
		{
			for (int j = 0; j < sx - tx; j++)
			{
				cout << "L";
			}
		}

		if (sy < ty)
		{
			for (int j = 0; j < ty - sy; j++)
			{
				cout << "D";
			}
		}
		else if (sy > ty)
		{
			for (int j = 0; j < sy - ty; j++)
			{
				cout << "U";
			}
		}

		cout << endl;
		cout.flush();

		int length;
		cin >> length;
	}
}