#include "bits/stdc++.h"

using ll = long long;

struct MCFGraph {
    struct Edge {
        int v, c;
        double f;
        Edge(int v, int c, double f) : v(v), c(c), f(f) {}
    };
    const int n;
    std::vector<Edge> e;
    std::vector<std::vector<int>> g;
    std::vector<double> h, dis;
    std::vector<int> pre;
    bool dijkstra(int s, int t) {
        dis.assign(n, std::numeric_limits<double>::max());
        pre.assign(n, -1);
        std::priority_queue<std::pair<double, int>, std::vector<std::pair<double, int>>, std::greater<>> que;
        dis[s] = 0;
        que.emplace(0, s);
        while (!que.empty()) {
            double d = que.top().first;
            int u = que.top().second;
            que.pop();
            if (dis[u] < d) continue;
            for (int i : g[u]) {
                int v = e[i].v;
                int c = e[i].c;
                double f = e[i].f;
                if (c > 0 && dis[v] > d + h[u] - h[v] + f) {
                    dis[v] = d + h[u] - h[v] + f;
                    pre[v] = i;
                    que.emplace(dis[v], v);
                }
            }
        }
        return dis[t] != std::numeric_limits<double>::max();
    }
    MCFGraph(int n) : n(n), g(n) {}
    void addEdge(int u, int v, int c, int f) {
        g[u].push_back(e.size());
        e.emplace_back(v, c, f);
        g[v].push_back(e.size());
        e.emplace_back(u, 0, -f);
    }
    std::pair<int, double> flow(int s, int t) {
        int flow = 0;
        double cost = 0;
        h.assign(n, 0);
        while (dijkstra(s, t)) {
            for (int i = 0; i < n; ++i) h[i] += dis[i];
            int aug = std::numeric_limits<int>::max();
            for (int i = t; i != s; i = e[pre[i] ^ 1].v) aug = std::min(aug, e[pre[i]].c);
            for (int i = t; i != s; i = e[pre[i] ^ 1].v) {
                e[pre[i]].c -= aug;
                e[pre[i] ^ 1].c += aug;
            }
            flow += aug;
            cost += double(aug) * h[t];
        }
        return std::make_pair(flow, cost);
    }
};

std::vector<std::pair<int, int>> players, ropes;
using std::cin, std::cout;

int h_dis(const std::pair<int, int> &a, const std::pair<int, int> &b) {
    return std::abs(a.first - b.first) + std::abs(a.second - b.second);
}

double e_dis(const std::pair<int, int> &a, const std::pair<int, int> &b) {
    return std::sqrt((a.first - b.first) * (a.first - b.first) + (a.second - b.second) * (a.second - b.second));
}

bool check(int mid, std::vector<std::pair<int, int>> &ans) {
    MCFGraph g(players.size() * 2 + 5);
    std::vector<std::tuple<int, int, int>> edge_id;
    edge_id.reserve(players.size() * ropes.size());
    for(int i = 0; i < players.size(); i++) {
        for(int j = 0; j < ropes.size(); j++) {
            if(h_dis(players[i], ropes[j]) > mid) {
                continue;
            }
            edge_id.emplace_back(i, j, g.e.size());
            g.addEdge(i, j + players.size(), 1, e_dis(players[i], ropes[j]));
        }
    }
    int s = players.size() * 2;
    int t = s + 1;
    for(int i = 0; i < players.size(); i++) {
        g.addEdge(s, i, 1, 0);
        g.addEdge(i + players.size(), t, 1, 0);
    }
    auto [flow, cost] = g.flow(s, t);
    if(flow != players.size()) {
        return false;
    } else {
        ans.clear();
        for(auto &[u, v, id] : edge_id) {
            if(g.e[id].c == 0) {
                ans.emplace_back(u, v);
            }
        }
        return true;
    }
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n, a, b;
    cin >> n >> a >> b;
    players.resize(n);
    ropes.resize(n);
    std::vector maze(a+1, std::vector<bool>(b+1, false));
    for(auto &[x, y] : players) {
        cin >> x >> y;
    }
    for(auto &[x, y] : ropes) {
        cin >> x >> y;
        // maze[x][y] = true;
    }
    std::vector<std::pair<int, int>> match;
    int l = 0, r = a + b;
    while(l < r) {
        int mid = (l + r) >> 1;
        if(check(mid, match)) {
            r = mid;
        } else {
            l = mid + 1;
        }
    }
    cout << l << std::endl;
    std::vector<std::string> moves(n);
    auto pp = players;
    std::mt19937 eng(std::random_device{}());
    for(int _=0; _<l; _++){
        auto vis = maze;
        auto ppp = pp;
        bool fl = true;
        for(auto[u, v] : match) {
            auto&[x, y] = ppp[u];
            auto[a, b] = ropes[v];
            auto c = std::abs(x-a) + std::abs(y-b);

            if(x > a && !vis[x-1][y]) {
                moves[u] += 'U';
                x--;
                goto nxt;
            }
            if(y > b && !vis[x][y-1]) {
                moves[u] += 'L';
                y--;
                goto nxt;
            }
            if(x < a && !vis[x+1][y]) {
                moves[u] += 'D';
                x++;
                goto nxt;
            }
            if(y < b && !vis[x][y+1]) {
                moves[u] += 'R';
                y++;
                goto nxt;
            }
            moves[u] += 'P';
            if(x != a || y != b && c+_>=l){
                fl = false;
            }
            nxt:;
            vis[x][y] = true;
        }
        if(!fl){
            _--;
            for(int j=0; j<n; j++) moves[j].pop_back();
            std::shuffle(match.begin(), match.end(), eng);
            continue;
        }
        swap(ppp, pp);
    }
    for(auto[u, v] : match) {
        auto[x, y] = players[u];
        auto[a, b] = ropes[v];
        std::cout << x << ' ' << y << ' '
        << a << ' ' << b << ' ' << moves[u] << '\n';
    }
    return 0;
}