#include <bits/stdc++.h>   const int maxn = 1e5, maxm = 1e5, maxCell = 1e5;   const int maxv = maxCell + 4, maxe = maxCell * 4 + 4 * maxCell;   const int inf = std::numeric_limits<int>::max() / 2;   namespace Network {   struct GraphInfo {     int vertex, source, sink;   };   struct Edge {     int from, to;     mutable int flow;     const Edge *pre, *rev;   } ed[maxe * 2 + 10], *end = ed;   const Edge *head[maxv + 10], *cur[maxv + 10];   int exceed[maxv + 10], dep[maxv + 10];   enum class EdgeType { Normal, Required };   inline void addGraphEdge(const int from, const int to, const int flow) {     new (end) Edge{from, to, flow, head[from], end + 1};     head[from] = end++;     new (end) Edge{to, from, 0, head[to], end - 1};     head[to] = end++;   }   template <EdgeType et>   inline void addUnitEdge(const int from, const int to) {     if constexpr (et == EdgeType::Required) {       --exceed[from];       ++exceed[to];     } else       addGraphEdge(from, to, 1);   }   bool bfs(const int n, const int source, const int sink) {     std::queue<int> q;     std::fill(dep, dep + n, inf);     q.push(source);     dep[source] = 0;     while (!q.empty()) {       const int cur = q.front();       q.pop();       for (const Edge *i = head[cur]; i; i = i->pre)         if (i->flow && dep[i->to] == inf) {           dep[i->to] = dep[cur] + 1;           q.push(i->to);         }     }     return dep[sink] != inf;   }   int dfs(const int x, const int cap, const int sink) {     if (x == sink || !cap) return cap;     int rst = cap;     for (; cur[x]; cur[x] = cur[x]->pre) {       const Edge *i = cur[x];       if (i->flow && dep[i->to] == dep[x] + 1) {         const int d = dfs(i->to, std::min(rst, i->flow), sink);         i->flow -= d;         i->rev->flow += d;         rst -= d;         if (!rst) break;       }     }     return cap - rst;   }   int dinic(const GraphInfo gi) {     int ret = 0;     while (bfs(gi.vertex, gi.source, gi.sink)) {       std::memcpy(cur, head, sizeof(cur[0]) * gi.vertex);       ret += dfs(gi.source, inf, gi.sink);     }     return ret;   }   bool hasSolution(const int virtSource) {     for (const Edge *i = head[virtSource]; i; i = i->pre)       if (i->flow) return false;     return true;   }   void init(const int n) {     end = ed;     std::memset(head, 0, sizeof(head[0]) * (n + 2));     std::memset(exceed, 0, sizeof(exceed[0]) * (n + 2));   }   int findMatch(const int v, const int limit) {     for (const Edge *i = head[v]; i; i = i->pre)       if (!i->flow && i->to < limit) return i->to;     return limit;   }   bool boundMaxFlow(const GraphInfo gi) {     const int virtSource = gi.vertex, virtSink = virtSource + 1;     addGraphEdge(gi.sink, gi.source, inf);     for (int i = 0; i < gi.vertex; ++i)       if (exceed[i] > 0)         addGraphEdge(virtSource, i, exceed[i]);       else if (exceed[i] < 0)         addGraphEdge(i, virtSink, -exceed[i]);     dinic(GraphInfo{virtSink + 1, virtSource, virtSink});     return hasSolution(virtSource);   }   }  // namespace Network   int n, m;   enum Direction { Left, Right, Down, Up, None };   const Direction reverse[]{Right, Left, Up, Down, None};   struct Step {     int dx, dy;     inline bool operator==(const Step s) const {       return dx == s.dx && dy == s.dy;     }   };   const Step step[]{{0, -1}, {0, 1}, {1, 0}, {-1, 0}};   const char directionName[] = { L ,  R ,  D ,  U };   struct Position {     int x, y;     inline static Position fromId(const int id) {       const div_t d = div(id, m);       return Position{d.quot, d.rem};     }     inline Position operator+(const struct Step s) const {       return Position{x + s.dx, y + s.dy};     }     inline Step operator-(const Position r) const {       return Step{x - r.x, y - r.y};     }     inline bool isValid() const { return x >= 0 && y >= 0 && x < n && y < m; }     inline int id() const { return x * m + y; }   };   struct Cell {     Direction next;     int sum, val;   } cell[maxCell + 10];   namespace GraphBuilder {   template <bool rev, Network::EdgeType type>   inline void linkVertex(const int from, const int to) {     if constexpr (rev)       Network::addUnitEdge<type>(to, from);     else       Network::addUnitEdge<type>(from, to);   }   template <bool toSink>   inline void linkCell(const Position pos, const int endpoint) {     using Network::EdgeType;     const int cid = pos.id();     Cell &cur = cell[cid];     cur.next = Direction::None;     for (int k = 0; k < 4; ++k)       if (const auto nxt = pos + step[k]; nxt.isValid()) {         const int nextId = nxt.id();         if (cell[nextId].sum < cur.sum)           cur.next = static_cast<Direction>(k);         else if (!toSink && cell[nextId].sum == cur.sum)           Network::addUnitEdge<EdgeType::Normal>(cid, nextId);       }     if (cur.next == Direction::None)       linkVertex<toSink, EdgeType::Required>(endpoint, cid);     else       linkVertex<toSink, EdgeType::Normal>(endpoint, cid);   }   inline bool isLinkSink(const Position &p) {     return (p.x & 0x01) ^ (p.y & 0x01);   }   static Network::GraphInfo build(const int n, const int m) {     const int source = n * m, sink = source + 1;     Network::init(sink + 1);     for (int i = 0; i < n; ++i)       for (Position pos{i, 0}; pos.y < m; ++pos.y)         if (isLinkSink(pos))           linkCell<true>(pos, sink);         else           linkCell<false>(pos, source);     return Network::GraphInfo{sink + 1, source, sink};   }   }  // namespace GraphBuilder   void construct(const int n, const int m) {     const int lim = n * m;     for (int i = 0, cid = 0; i < n; ++i)       for (Position pos{i, 0}; pos.y < m; ++pos.y, ++cid)         if (Cell &cur = cell[cid]; cur.next != Direction::None)           cur.val = cur.sum - cell[(pos + step[cur.next]).id()].sum;     for (int i = 0, cid = 0; i < n; ++i)       for (Position pos{i, 0}; pos.y < m; ++pos.y, ++cid)         if (!GraphBuilder::isLinkSink(pos))           if (const int nxt = Network::findMatch(cid, lim); nxt < lim) {             Cell &cur = cell[cid];             const int typ =                 std::find(step, step + 4, Position::fromId(nxt) - pos) - step;             cur.val = cur.sum - 1;             cur.next = static_cast<Direction>(typ);             cell[nxt].val = 1;             cell[nxt].next = reverse[typ];           }   }   template <class Func>   void printMatrix(const int n, const int m, Func fun) {     const Cell *ptr = cell;     for (int i = 0; i < n; ++i) {       for (int j = 0; j < m; ++j, ++ptr) std::cout << fun(*ptr) <<    ;       std::cout.put(  n );     }   }   void solve() {     std::cin >> n >> m;     for (Cell *i = cell; i < cell + n * m; ++i) std::cin >> i->sum;     if (!Network::boundMaxFlow(GraphBuilder::build(n, m)))       std::cout <<  NO n ;     else {       construct(n, m);       std::cout <<  YES n ;       printMatrix(n, m, [](const Cell &i) { return i.val; });       printMatrix(n, m, [](const Cell &i) { return directionName[i.next]; });     }   }   int main() {     std::ios::sync_with_stdio(false);     int t;     std::cin >> t;     for (int i = t; i; --i) solve();     return 0;   }