#include <bits/stdc++.h>

using namespace std;

#define rep(i, a, n) for (auto i = a; i <= (n); ++i)
#define sz(a) (int)(a).size()
using vi = vector<int>;

template<class Cap = int, Cap Cap_MAX = numeric_limits<Cap>::max()>

struct Dinic{
	int n;
	struct E { int to; Cap a; };
	vector<E> es;
	vector<vi> g;
	vi dis;
	
	Dinic(int n): n(n), g(n) {}
	
	int addEdge(int u, int v, Cap c, bool dir = 1) {
		int ret = sz(es);
		g[u].push_back(sz(es)); es.push_back({v, c});
		g[v].push_back(sz(es)); es.push_back({u, dir ? 0 : c});
		return ret;
	}
	
	Cap MaxFlow(int src, int sink) {
		auto revbfs = [&]() {
			dis.assign(n, -1);
			dis[sink] = 0;
			vi que{sink};
			
			rep(ind, 0, sz(que) - 1) {
				int now = que[ind];
				for (auto i: g[now]) {
					int v = es[i].to;
					if (es[i ^ 1].a > 0 && dis[v] == -1) {
						dis[v] = dis[now] + 1;
						que.push_back(v);
						if (v == src) return 1;
					}
				}
			}
			return 0;
		};
		
		vi cur;
		
		auto dfs = [&] (auto &dfs, int now, Cap flow) {
			if (now == sink) return flow;
			Cap res = 0;
			for (int &ind = cur[now]; ind < sz(g[now]); ind++) {
				int i = g[now][ind];
				auto [v, c] = es[i];
				if (c > 0 && dis[v] == dis[now] - 1) {
					Cap x = dfs(dfs, v, min(flow - res, c));
					res += x;
					es[i].a -= x;
					es[i ^ 1].a += x;
				}
				if (res == flow) break;
			}
			return res;
		} ;
		
		Cap ans = 0;
		while (revbfs()) {
			cur.assign(n, 0);
			ans += dfs(dfs, src, Cap_MAX);
		}
		return ans;
	}
};

const int maxn = 205;
int n, a, b, tot = 0;
int sx[maxn], sy[maxn], ex[maxn], ey[maxn];
int rope[maxn];
char op[1000005];

const int dx[5] = {-1, 0, 1, 0, 0};
const int dy[5] = {0, -1, 0, 1, 0};
const char OP[] = "DRULS";

char buf[maxn];

void findPath(int u, int t, int &id, int &len, Dinic<int> &flow) {
	if (u >= tot - n && u <= tot - 1) {
		id = u - (tot - n);
		return;
	}
	for (auto i: flow.g[u]) {
		auto [v, c] = flow.es[i];
		if (v > u && !c) {
			if (op[i]) buf[len++] = op[i];
			++flow.es[i].a;
			findPath(v, t, id, len, flow);
			return;
		}
	}
	assert(-1);
}

int main(){
	scanf("%d%d%d", &n, &a, &b);
	
	int s = tot++, t = tot++;
	int T_max = 200;
	vector<vector<vector<int> > > in, out;
	in.resize(T_max), out.resize(T_max);
	for (int i = 0; i < T_max; ++i) {
		in[i].resize(a + 1), out[i].resize(a + 1);
		for (int x = 1; x <= a; ++x) {
			in[i][x].resize(b + 1), out[i][x].resize(b + 1);
			for (int y = 1; y <= b; ++y)
				in[i][x][y] = tot++, out[i][x][y] = tot++;
			}
	}
	for (int i = 0; i < n; ++i) {
		scanf("%d%d", sx + i, sy + i);
	}	
	for (int i = 0; i < n; ++i) {
		scanf("%d%d", ex + i, ey + i);
		rope[i] = tot++;	
	} // [tot - n, tot - 1]
	Dinic<int> flow(tot);
	
	int cnt = 0;
	for (int i = 0; i < T_max; ++i) {
		// add the i-th layer
		if (i == 0) {
			for (int j = 0; j < n; ++j) {
				assert(sx[j] >= 1 && sx[j] <= a && sy[j] >= 1 && sy[j] <= b);
				flow.addEdge(s, in[i][sx[j]][sy[j]], 1);
				flow.addEdge(rope[j], t, 1);
			}
		}
		for (int x = 1; x <= a; ++x)
			for (int y = 1; y <= b; ++y) {
				if (i != 0)	{
					for (int k = 0; k < 5; ++k) {
						int nx = x + dx[k], ny = y + dy[k];
						if (nx >= 1 && nx <= a && ny >= 1 && ny <= b) {
							int id = flow.addEdge(out[i - 1][nx][ny], in[i][x][y], 1);
							op[id] = OP[k];
						}
					}
				}
				flow.addEdge(in[i][x][y], out[i][x][y], 1);
			}
		for (int j = 0; j < n; ++j)
			flow.addEdge(out[i][ex[j]][ey[j]], rope[j], 1);
			
		cnt += flow.MaxFlow(s, t);
		if (cnt == n) {
			printf("%d\n", i);
			for (int j = 0; j < n; ++j) {
				int id = -1, len = 0;
				findPath(in[0][sx[j]][sy[j]], t, id, len, flow);
				assert(id != -1);
				printf("%d %d %d %d ", sx[j], sy[j], ex[id], ey[id]);
				for (int k = 0; k < len; ++k) putchar(buf[k]);
				for (int k = len; k < i; ++k) putchar('P');
				puts("");
			}
			return 0;
		}
	}
	return 0;
}