//qoj7999
#include <bits/stdc++.h>
using namespace std; typedef long long ll; namespace FastIO {
#if __cplusplus > 201700
#define INLINE_V inline
#else
#define INLINE_V
#endif
#if (defined(LOCAL) || defined(_WIN32)) && !defined(DISABLE_MMAP)
#define DISABLE_MMAP
#endif
#ifndef DISABLE_MMAP
#include <sys/mman.h>
#endif
INLINE_V constexpr int _READ_SIZE = 1 << 18; INLINE_V static char _read_buffer[_READ_SIZE], *_read_ptr = nullptr, *_read_ptr_end = nullptr;
inline char gc() { if (__builtin_expect(_read_ptr == _read_ptr_end, false)) { _read_ptr = _read_buffer; _read_ptr_end = _read_buffer + fread(_read_buffer, 1, _READ_SIZE, stdin); if (__builtin_expect(_read_ptr == _read_ptr_end, false)) return EOF;} return *_read_ptr++; }
INLINE_V constexpr int _WRITE_SIZE = 1 << 18; INLINE_V static char _write_buffer[_WRITE_SIZE], *_write_ptr = _write_buffer; inline void pc(char c) { *_write_ptr++ = c; if (__builtin_expect(_write_buffer + _WRITE_SIZE == _write_ptr, false)) { fwrite(_write_buffer, 1, _write_ptr - _write_buffer, stdout); _write_ptr = _write_buffer; } }
INLINE_V struct _auto_flush { ~_auto_flush() { fwrite(_write_buffer, 1, _write_ptr - _write_buffer, stdout); } } _auto_flush; inline bool _isdigit(char c) { return (c & 16) && c != EOF; } inline bool _isgraph(char c) { return c > 32 && c != EOF; }
template <class T> INLINE_V constexpr bool _is_integer = numeric_limits<T>::is_integer; template <class T> INLINE_V constexpr bool _is_signed = numeric_limits<T>::is_signed; template <class T> INLINE_V constexpr bool _is_unsigned = _is_integer<T> && !_is_signed<T>;
template <> INLINE_V constexpr bool _is_integer<__int128> = true; template <> INLINE_V constexpr bool _is_integer<__uint128_t> = true; template <> INLINE_V constexpr bool _is_signed<__int128> = true; template <> INLINE_V constexpr bool _is_unsigned<__uint128_t> = true;
inline void read(char &c) { do c = gc(); while (!_isgraph(c)); } inline void read_cstr(char *s) { char c = gc(); while (!_isgraph(c)) c = gc(); while (_isgraph(c)) *s++ = c, c = gc(); *s = 0; } inline void read(string &s) { char c = gc(); s.clear(); while (!_isgraph(c)) c = gc(); while (_isgraph(c)) s.push_back(c), c = gc(); }
template <class T, enable_if_t<_is_signed<T>, int> = 0> inline void read(T &x) { char c = gc(); bool f = true; x = 0; while (!_isdigit(c)) { if (c == 45) f = false; c = gc(); }
if (f) while (_isdigit(c)) x = x * 10 + (c & 15), c = gc(); else while (_isdigit(c)) x = x * 10 - (c & 15), c = gc(); } template <class T, enable_if_t<_is_unsigned<T>, int> = 0> inline void read(T &x) { char c = gc(); while (!_isdigit(c)) c = gc(); x = 0; while (_isdigit(c)) x = x * 10 + (c & 15), c = gc(); }
inline void write(char c) { pc(c); } inline void write_cstr(const char *s) { while (*s) pc(*s++); } inline void write(const string &s) { for (char c : s) pc(c); } template <class T, enable_if_t<_is_signed<T>, int> = 0> inline void write(T x) { char buffer[numeric_limits<T>::digits10 + 1]; int digits = 0; if (x >= 0) do buffer[digits++] = (x % 10) | 48, x /= 10; while (x);
else { pc(45); do buffer[digits++] = -(x % 10) | 48, x /= 10; while (x); } while (digits) pc(buffer[--digits]); } template <class T, enable_if_t<_is_unsigned<T>, int> = 0> inline void write(T x) { char buffer[numeric_limits<T>::digits10 + 1]; int digits = 0; do buffer[digits++] = (x % 10) | 48, x /= 10; while (x); while (digits) pc(buffer[--digits]); }
template <int N> struct _tuple_io_helper { template <class... T> static inline void _read(tuple<T...> &x) { _tuple_io_helper<N - 1>::_read(x), read(get<N - 1>(x)); } template <class... T> static inline void _write(const tuple<T...> &x) { _tuple_io_helper<N - 1>::_write(x), pc(32), write(get<N - 1>(x)); } };
template <> struct _tuple_io_helper<1> { template <class... T> static inline void _read(tuple<T...> &x) { read(get<0>(x)); } template <class... T> static inline void _write(const tuple<T...> &x) { write(get<0>(x)); } };
template <class... T> inline void read(tuple<T...> &x) { _tuple_io_helper<sizeof...(T)>::_read(x); } template <class... T> inline void write(const tuple<T...> &x) { _tuple_io_helper<sizeof...(T)>::_write(x); }
template <class T1, class T2> inline void read(pair<T1, T2> &x) { read(x.first), read(x.second); } template <class T1, class T2> inline void write(const pair<T1, T2> &x) { write(x.first), pc(32), write(x.second); }
template <class T1, class... T2> inline void read(T1 &x, T2 &...y) { read(x), read(y...); } template <class... T> inline void read_cstr(char *x, T *...y) { read_cstr(x), read_cstr(y...); }
template <class T1, class... T2> inline void write(const T1 &x, const T2 &...y) { write(x), write(y...); } template <class... T> inline void write_cstr(const char *x, const T *...y) { write_cstr(x), write_cstr(y...); }
template <class T> inline void print(const T &x) { write(x); } inline void print_cstr(const char *x) { write_cstr(x); } template <class T1, class... T2> inline void print(const T1 &x, const T2 &...y) { print(x), pc(32), print(y...); }
template <class... T> inline void print_cstr(const char *x, const T *...y) { print_cstr(x), pc(32), print_cstr(y...); } inline void println() { pc(10); } inline void println_cstr() { pc(10); }
template <class... T> inline void println(const T &...x) { print(x...), pc(10); } template <class... T> inline void printk(const T &...x) { print(x...), pc(32); } template <class... T> inline void println_cstr(const T *...x) { print_cstr(x...), pc(10); } } using namespace FastIO; void solve();int main(){ solve(); return 0; }

const int N = 510;
int T, n, r, c, a[N][N], flg, vs[N][N], ind[N*2], cnt[N], nw[N*2];
struct Graph{
	int hd[N*2], dep[N*2], now[N*2], tot = 1;
	struct edge{
		int eg, ln, nx, ban;
	} eg[N*N*5];
	void add(int u, int v, int w){
		eg[++tot] = { v, w, hd[u], 0 };
		hd[u] = tot;
	}
	bool bfs(int s, int t){
        memset(dep, 0, sizeof(dep));
        memcpy(now, hd, sizeof(hd));
        dep[s] = 1;
        queue<int> q;
        q.push(s);
        while(!q.empty()){
            int x = q.front();
            q.pop();
            for(int i = hd[x]; i; i = eg[i].nx){
                int y = eg[i].eg, z = eg[i].ln;
                if(!dep[y] && z && !eg[i].ban){
                    dep[y] = dep[x] + 1;
                    q.push(y);
                    if(y == t){
                        return 1;
                    }
                }
            }
        }
        return 0;
    }
    int dfs(int x, int t, int fl){
        if(x == t){
            return fl;
        }
        int rs = fl;
        for(int i = now[x]; i && rs; i = eg[i].nx){
            int y = eg[i].eg, z = eg[i].ln;
            now[x] = i;
            if(dep[y] == dep[x] + 1 && z && !eg[i].ban){
                int k = dfs(y, t, min(z, rs));
                if(!k){
                    dep[y] = 0;
                }
                eg[i].ln -= k;
                eg[i^1].ln += k;
                rs -= k;
            }
        }
        return fl - rs;
    }
    int dinic(int s, int t){
        int mf = 0, tmp = 0;
        while(bfs(s, t)){
            while(tmp = dfs(s, t, 1000)){
                mf += tmp;
            }
        }
        return mf;
    }
	void init(){
		tot = 1;
		memset(hd, 0, sizeof(hd));
	}
	int fl(){
		for(int i = 1; i <= n; ++ i){
			add(0, i, 1);
			add(i, 0, 0);
			add(i+n, n+n+1, 1);
			add(n+n+1, i+n, 0);
		}
		return dinic(0, n+n+1);
	}
} g, G[60];

void eular(int d, int deg){
	memset(ind, 0, sizeof(ind));
	memcpy(nw, G[d].hd, sizeof(nw));
	for(int i = 1; i <= n+n; ++ i){
		ind[i] = deg;
	}
	queue<int> q;
	for(int i = 1; i <= n; ++ i){
		if(ind[i]){
			q.push(i);
			int cl = 2;
			while(!q.empty()){
				int x = q.front();
				q.pop();
				for(int i = nw[x]; i; i = G[d].eg[i].nx){
					nw[x] = i;
					int y = G[d].eg[i].eg;
					bool chk = (x < y) ? G[d].eg[i].ln : !G[d].eg[i].ln;
					if(y != 0 && y != n+n+1 && ind[y] && chk && !G[d].eg[i].ban){
						-- ind[x];
						G[d].eg[i].ban = G[d].eg[i^1].ban = cl;
						cl = 5 - cl;
						q.push(y);
						break;
					}
				}
			}
		}
	}
}

void pp1(int l, int r, int d){
	if(l == r){
		for(int j = 1; j <= n; ++ j){
			for(int k = G[d].hd[j]; k; k = G[d].eg[k].nx){
				if(G[d].eg[k].eg > n && !G[d].eg[k].ban){
					a[G[d].eg[k].eg-n][l] = j;
					G[d].eg[k].ban = G[d].eg[k^1].ban = 1;
				}
			}
		}
		return;
	}
	if((r - l + 1) & 1){
		int i = l;
		G[d].fl();
		for(int j = 1; j <= n; ++ j){
			for(int k = G[d].hd[j]; k; k = G[d].eg[k].nx){
				if(G[d].eg[k].eg > n && !G[d].eg[k].ln && !G[d].eg[k].ban){
					a[G[d].eg[k].eg-n][i] = j;
					G[d].eg[k].ban = G[d].eg[k^1].ban = 1;
				}
			}
		}
		++ l;
	}
	int mid = l + r >> 1;
	eular(d, r-l+1);
	G[d+2].init();
	G[d+3].init();
	for(int x = 1; x <= n; ++ x){
		for(int j = G[d].hd[x]; j; j = G[d].eg[j].nx){
			int y = G[d].eg[j].eg;
			if(G[d].eg[j].ban == 3){
				G[d+2].add(x, y, 1);
				G[d+2].add(y, x, 0);
			} else if(G[d].eg[j].ban == 2){
				G[d+3].add(x, y, 1);
				G[d+3].add(y, x, 0);
			}
		}
	}
	pp1(l, mid, d+2);
	pp1(mid+1, r, d+3);
}
void pr1(){
	G[0].init();
	memset(vs, 0, sizeof(vs));
	memset(cnt, 0, sizeof(cnt));
	for(int i = 1; i <= r; ++ i){
		for(int j = 1; j <= c; ++ j){
			vs[a[i][j]][i] = 1;
			++ cnt[a[i][j]];
		}
	}
	for(int i = 1; i <= n; ++ i){
		cnt[i] = r - cnt[i];
		if(cnt[i] > n-c){
			flg = 0;
			return;
		}
		for(int j = 1; j <= r; ++ j){
			if(!vs[i][j]){
				G[0].add(i, j+n, 1);
				G[0].add(j+n, i, 0);
			}
		}
	}
	for(int i = r + 1, nw = 1; i <= n; ++ i){
		for(int j = 1; j <= n-c; ++ j){
			while(cnt[nw] == n - c){
				++ nw;
			}
			G[0].add(nw, i+n, 1);
			G[0].add(i+n, nw, 0);
			++ cnt[nw];
		}
	}
	pp1(c+1, n, 0);
}
void pp2(int l, int r, int d){
	if(l == r){
		for(int j = 1; j <= n; ++ j){
			for(int k = G[d].hd[j]; k; k = G[d].eg[k].nx){
				if(G[d].eg[k].eg > n && !G[d].eg[k].ban){
					a[l][G[d].eg[k].eg-n] = j;
					G[d].eg[k].ban = G[d].eg[k^1].ban = 1;
				}
			}
		}
		return;
	}
	if((r - l + 1) & 1){
		int i = l;
		G[d].fl();
		for(int j = 1; j <= n; ++ j){
			for(int k = G[d].hd[j]; k; k = G[d].eg[k].nx){
				if(G[d].eg[k].eg > n && !G[d].eg[k].ln && !G[d].eg[k].ban){
					a[i][G[d].eg[k].eg-n] = j;
					G[d].eg[k].ban = G[d].eg[k^1].ban = 1;
				}
			}
		}
		++ l;
	}
	if(l > r){
		return;
	}
	int mid = l + r >> 1;
	eular(d, r-l+1);
	G[d+2].init();
	G[d+3].init();
	for(int x = 1; x <= n; ++ x){
		for(int j = G[d].hd[x]; j; j = G[d].eg[j].nx){
			int y = G[d].eg[j].eg;
			if(G[d].eg[j].ban == 3){
				G[d+2].add(x, y, 1);
				G[d+2].add(y, x, 0);
			} else if(G[d].eg[j].ban == 2){
				G[d+3].add(x, y, 1);
				G[d+3].add(y, x, 0);
			}
		}
	}
	pp2(l, mid, d+2);
	pp2(mid+1, r, d+3);
}
void pr2(){
	static int vs[N][N];
	G[1].init();
	memset(vs, 0, sizeof(vs));
	for(int i = 1; i <= r; ++ i){
		for(int j = 1; j <= n; ++ j){
			vs[a[i][j]][j] = 1;
		}
	}
	for(int i = 1; i <= n; ++ i){
		for(int j = 1; j <= n; ++ j){
			if(!vs[i][j]){
				G[1].add(i, j+n, 1);
				G[1].add(j+n, i, 0);
			}
		}
	}
	pp2(r+1, n, 1);
}

void solve(){
	read(T);
	while(T--){
		read(n, r, c);
		flg = 1;
		for(int i = 1; i <= r; ++ i){
			for(int j = 1; j <= c; ++ j){
				read(a[i][j]);
			}
		}
		if(c < n){
			pr1();
		}
		if(flg){
			pr2();
			println_cstr("Yes");
			for(int i = 1; i <= n; ++ i){
				for(int j = 1; j <= n; ++ j){
					printk(a[i][j]);
				}
				print('\n');
			}
		} else {
			println_cstr("No");
		}
	}
}