#include <bits/stdc++.h>

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int t;
    std::cin >> t;
    for (int nCase = 1; nCase <= t; ++nCase) {
        int n, m, k;
        std::cin >> n >> m >> k;
        std::vector<int> x1(k), y1(k), x2(k), y2(k), c(k);
        for (int i = 0; i < k; ++i) {
            std::cin >> x1[i] >> y1[i] >> x2[i] >> y2[i] >> c[i];
            --x1[i], --x2[i], --y1[i], --y2[i];
        }
        std::vector<std::string> grid;
        
        auto tryConstruct = [&]() {
            
            std::vector<int> noCut(n + 1), nxt(n, n);
            for (int i = 0; i < k; ++i) {
                int l = x1[i], r = x2[i];
                if (l > r) std::swap(l, r);
                if (c[i] == 1) {
                    ++noCut[l + 1];
                    --noCut[r + 1];
                } else nxt[l] = std::min(nxt[l], r);
            }
            for (int i = 1; i <= n; ++i) noCut[i] += noCut[i - 1];
            for (int i = n - 2; i >= 0; --i) nxt[i] = std::min(nxt[i], nxt[i + 1]);
            
            std::vector<int> cand;
            for (int i = 0; i <= n; ++i)
                if (!noCut[i]) cand.push_back(i);
            
            std::vector<int> cuts;
            
            if (m % 2 == 1) {
                int lst = 0;
                for (auto r : cand) {
                    if (r % 2 == 1) {
                        if (r > nxt[lst]) return false;
                        cuts.push_back(r);
                        lst = r;
                    }
                }
                if (n > nxt[lst]) return false;
                if (m == 1 && int(cuts.size()) < n / 2) return false;
                if (cuts.empty()) return false;
            } else {
                int cnt = cand.size();
                std::vector<int> dp(cnt, -1);
                
                dp[0] = 0;
                for (int i = 0; i < cnt - 1; ++i) {
                    if (dp[i] == -1) continue;
                    for (int j = 0; j <= i + 3 && j < cnt; ++j) {
                        if (cand[j] > nxt[cand[i]]) continue;
                        if (cand[i] == 0 && cand[j] == n) {
                            if (n < 3 || m < 4) continue;
                        } else if (cand[i] != 0 && cand[j] != n && cand[j] - cand[i] < 2) continue;
                        dp[j] = i; 
                    }
                }
                if (dp[cnt - 1] == -1) return false;
                
                for (int i = dp[cnt - 1]; i != 0; i = dp[i]) cuts.push_back(cand[i]);
                std::reverse(cuts.begin(), cuts.end());
            }
            
            grid.assign(n, std::string(m, '?'));
            
            if (cuts.empty()) {
                assert(n >= 3 && m >= 4 && m % 2 == 0);
                grid[0][0] = grid[2][2] = 'R';
                grid[0][1] = grid[2][3] = 'L';
                grid[0][2] = grid[0][3] = grid[1][0] = grid[1][1] = 'D';
                grid[1][2] = grid[1][3] = grid[2][0] = grid[2][1] = 'U';
                for (int i = 4; i < m; ++i) {
                    grid[0][i] = 'D';
                    grid[1][i] = 'U';
                    grid[2][i] = "RL"[i % 2];
                }
                for (int i = 3; i < n; ++i)
                    for (int j = 0; j < m; ++j) grid[i][j] = "RL"[j % 2];
            } else {
                auto fill = [&](int l, int r) {
                    for (int i = l; i < r; ++i) {
                        for (int j = 0; j + 1 < m; j += 2) {
                            grid[i][j] = 'R';
                            grid[i][j + 1] = 'L';
                        }
                    }
                    if (m % 2 == 1) {
                        for (int i = l; i < r; i += 2) {
                            grid[i][m - 1] = 'D';
                            grid[i + 1][m - 1] = 'U';
                        }
                    }
                };
                
                fill(0, cuts[0] - 1);
                fill(cuts.back() + 1, n);
                for (int i = 0; i + 1 < int(cuts.size()); ++i) fill(cuts[i] + 1, cuts[i + 1] - 1);
                for (auto r : cuts) {
                    grid[r - 1] = std::string(m, 'D');
                    grid[r] = std::string(m, 'U');
                }
            }
            
            return true;
        };
        
        std::cout << "Case #" << nCase << ": ";
        if (tryConstruct()) {
            std::cout << "Yes\n";
            for (int i = 0; i < n; ++i) std::cout << grid[i] << "\n";
            continue;
        }
        
        std::swap(n, m);
        for (int i = 0; i < k; ++i) {
            std::swap(x1[i], y1[i]);
            std::swap(x2[i], y2[i]);
        }
        
        if (tryConstruct()) {
            std::cout << "Yes\n";
            for (int i = 0; i < m; ++i) {
                for (int j = 0; j < n; ++j) {
                    char ch = grid[j][i];
                    if (ch == 'R') ch = 'D';
                    else if (ch == 'D') ch = 'R';
                    else if (ch == 'L') ch = 'U';
                    else ch = 'L';
                    std::cout << ch;
                }
                std::cout << "\n";
            }
        } else std::cout << "No\n";
    }
    
    return 0;
}