# Import required libraries
from typing import List, Tuple
from dataclasses import dataclass

# Constants
N = 2_000_010  # Equivalent to 2e6+10 in C++
MAX_SIZE = 314  # Size for 2D arrays
MAX_ANS = 410  # Size for answer arrays

# Global variables
n = m = idx = 0
a = [[0] * MAX_SIZE for _ in range(MAX_SIZE)]  # Main grid
b = [[0] * MAX_SIZE for _ in range(MAX_SIZE)]  # Backup grid
ans = [[] for _ in range(MAX_ANS)]  # Store paths

def check() -> bool:
    """
    Check if current configuration is valid and construct paths
    Returns: True if valid solution found, False otherwise
    """
    global idx
    idx = 0
    now = []  # List of (position, index) pairs
    
    # Process first row
    for j in range(m-1, -1, -1):
        if a[0][j] == 1:
            idx += 1
            ans[idx].append(0)
            ans[idx].append(j)
            # Flip bits
            for i in range(j+1):
                a[0][i] ^= 1
            now.append((j, idx))
    
    # Process middle rows
    for i in range(1, n-1):
        # Apply previous operations
        for x, y in now:
            a[i][x] ^= 1
            
        now.sort(reverse=True)  # Sort by position descending
        p = 0
        nw = []  # New operations
        
        # Process current row
        for j in range(m-1, 0, -1):
            if a[i][j] == 0:
                continue
                
            # Apply pending operations
            while p < len(now) and now[p][0] >= j:
                nw.append(now[p])
                ans[now[p][1]].append(now[p][0])
                p += 1
                
            # Add new operations if needed
            if p >= len(now):
                idx += 1
                for k in range(i+1):
                    ans[idx].append(0)
                now.append((0, idx))
                idx += 1
                for k in range(i+1):
                    ans[idx].append(0)
                now.append((0, idx))
            
            # Flip bits
            for k in range(now[p][0]+1, j+1):
                a[i][k] ^= 1
            now[p] = (j, now[p][1])
            ans[now[p][1]].append(j)
            nw.append(now[p])
            p += 1
        
        # Check if first column is valid
        if a[i][0]:
            return False
            
        # Add remaining operations
        while p < len(now):
            nw.append(now[p])
            ans[now[p][1]].append(now[p][0])
            p += 1
            
        now = nw
    
    # Process last row
    for x, y in now:
        for i in range(x, m):
            a[n-1][i] ^= 1
        ans[y].append(m-1)
    
    # Verify final state
    for i in range(n):
        for j in range(m):
            if a[i][j]:
                return False
    
    # Output solution
    print("YES")
    print(idx)
    assert idx <= n + m
    
    # Construct and output paths
    for i in range(1, idx+1):
        s = ""
        for j in range(1, len(ans[i])):
            s += "R" * (ans[i][j] - ans[i][j-1])
            if j != len(ans[i])-1:
                s += "D"
        print(s)
        assert len(s) == n + m - 2
        
    return True

def solve() -> None:
    """
    Main solving function for each test case
    """
    global n, m
    n, m = map(int, input().split())
    
    # Read input grid
    for i in range(n):
        s = input()
        for j in range(m):
            b[i][j] = 1 if s[j] == 'W' else 0
    
    # Try original configuration
    for i in range(n):
        for j in range(m):
            a[i][j] = b[i][j]
    
    for i in range(MAX_ANS):
        ans[i].clear()
    
    if check():
        return
    
    # Try inverted configuration
    for i in range(n):
        for j in range(m):
            b[i][j] ^= 1
            a[i][j] = b[i][j]
    
    for i in range(MAX_ANS):
        ans[i].clear()
    
    if check():
        return
    
    print("NO")

# Main execution
t = int(input())  # Number of test cases
for _ in range(t):
    solve()