#include<bits/stdc++.h>
using namespace std;
#define pr pair<int, int>
#define pb push_back
#define mid (l + r) / 2
#define ls num << 1
#define rs num << 1 | 1

inline int read() {
    int x = 0, m = 1;
    char ch = getchar();

    while (!isdigit(ch)) {
        if (ch == '-') m = -1;
        ch = getchar();
    }

    while (isdigit(ch)) {
        x = x * 10 + ch - 48;
        ch = getchar();
    }

    return x * m;
}

inline void write(int x) {
    if (x < 0) {
        putchar('-');
        write(-x);
        return;
    }

    if (x >= 10) write(x / 10);
    putchar(x % 10 + '0');
}

mt19937_64 rnd(chrono :: system_clock().now().time_since_epoch().count());

const int N = 505, M = N * N;

int c[N], a[N][N], vis[N], id[N];
int total;
vector<pr> Ans[N];

#define Pr pair<pr, int>

struct K_regular_bipartite_graph {
    vector<pr> edge, ans;
    vector<int> del, L[N], R[N];
    int n, Lt[N], Rt[N], cnt, vis[N];
    stack<Pr> st;

    void init(int m) {
        cnt = 0;
        n = m;
        for (int i = 1; i <= n; i++) L[i].clear(), R[i].clear(), Lt[i] = Rt[i] = 0;
        ans.clear();
        edge.clear();
        del.clear();
        while (!st.empty()) st.pop();
    }

    void add(int x, int y) {
        L[x].pb(edge.size());
        del.pb(0);
        edge.pb({x, y});
        cnt++;
    }

    void dfs(int ro) {
        if (vis[ro]) {
            int now;
            do {
                now = st.top().first.first;
                vis[now] = 0;
                st.pop();
            } while (now != ro);
        }
        vis[ro] = 1;
        int pos;
        do {
            pos = rnd() % L[ro].size();
            while (del[L[ro][pos]]) {
                swap(L[ro][pos], L[ro].back());
                L[ro].pop_back();
                pos = rnd() % L[ro].size();
            }
        } while (Lt[ro] == L[ro][pos]);
        int id = L[ro][pos], to = edge[id].second;
        st.push({{ro, to}, id});
        if (Rt[to] == -1) return;
        int Id = Rt[to];
        int To = edge[Id].first;
        dfs(To);
    }

    vector<pr> get() {
        for (int i = 1; i <= n; i++) Lt[i] = Rt[i] = -1, vis[i] = 0;
        for (int i = 1; i <= n; i++) {
            dfs(i);
            while (!st.empty()) {
                int x = st.top().first.first, y = st.top().first.second, id = st.top().second;
                st.pop();
                vis[x] = 0;
                Lt[x] = Rt[y] = id;
            }
        }
        ans.clear();
        for (int i = 1; i <= n; i++) {
            assert(Lt[i] != -1);
            ans.pb(edge[Lt[i]]);
            del[Lt[i]] = 1;
            cnt--;
        }
        return ans;
    }

    void Dfs(int ro, int type) {
        if (!type) {
            for (int &i = Lt[ro]; i < L[ro].size(); ) {
                if (del[L[ro][i]]) {
                    i++;
                }
                else {
                    del[L[ro][i]] = 1;
                    int id = L[ro][i], to = edge[id].second;
                    i++;
                    Dfs(to, 1);
                    ans.pb(edge[id]);
                }
            }
        }
        else {
            for (int &i = Rt[ro]; i < R[ro].size(); ) {
                if (del[R[ro][i]]) {
                    i++;
                }
                else {
                    del[R[ro][i]] = 1;
                    int id = R[ro][i], to = edge[id].first;
                    i++;
                    Dfs(to, 0);
                    ans.pb(edge[id]);
                }
            }
        }
    }

    pair<vector<pr>, vector<pr>> split() {
        for (int i = 1; i <= n; i++) R[i].clear();
        for (int i = 1; i <= n; i++) {
            for (int j = L[i].size() - 1; j >= 0; j--) {
                if (del[L[i][j]]) {
                    swap(L[i][j], L[i].back());
                    L[i].pop_back();
                }
            }
            for (auto u : L[i]) {
                int to = edge[u].second;
                R[to].pb(u);
            }
            Lt[i] = Rt[i] = 0;
        }
        ans.clear();
        for (int i = 1; i <= n; i++) Dfs(i, 0);
        vector<pr> AnsL, AnsR;
        for (int i = 0; i < ans.size(); i += 2) {
            AnsL.pb(ans[i]);
            AnsR.pb(ans[i + 1]);
        }
        return {AnsL, AnsR};
    }

    int size() {
        return cnt / n;
    }
};

void solve(K_regular_bipartite_graph A) {
    if (A.size() & 1) {
        total++;
        Ans[total] = A.get();
    }
    if (A.size()) {
        auto res = A.split();
        K_regular_bipartite_graph B;
        B.init(A.n);
        for (auto u : res.first) {
            B.add(u.first, u.second);
        }
        solve(B);
        B.init(A.n);
        for (auto u : res.second) {
            B.add(u.first, u.second);
        }
        solve(B);
    }
}

signed main() {
    int t = read();

    while (t--) {
        int n = read(), R = read(), C = read();

        for (int i = 1; i <= n; i++) c[i] = 0;

        for (int i = 1; i <= R; i++) {
            for (int j = 1; j <= C; j++) {
                a[i][j] = read();
                c[a[i][j]]++;
            }
        }

        int P = 1;

        for (int i = 1; i <= n; i++) {
            if (c[i] < R + C - n) {
                P = 0;
                break;
            }
        }

        if (!P) {
            puts("No");
            continue;
        }
        puts("Yes");

        for (int i = 1; i <= n; i++) c[i] = n - C;

        K_regular_bipartite_graph A;
        A.init(n);

        for (int i = 1; i <= R; i++) {
            for (int j = 1; j <= n; j++) vis[j] = 1;
            for (int j = 1; j <= C; j++) {
                vis[a[i][j]] = 0;
            }
            for (int j = 1; j <= n; j++) {
                if (vis[j]) {
                    c[j]--;
                    A.add(i, j);
                }
            }
        }

        for (int i = R + 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) id[j] = j;
            sort(id + 1, id + n + 1, [&](int x, int y) {
                return c[x] > c[y];
            });
            for (int j = 1; j <= n - C; j++) {
                A.add(i, id[j]);
                c[id[j]]--;
            }
        }

        solve(A);

        for (int i = 1; i <= total; i++) {
            for (auto u : Ans[i]) {
                if (u.first <= R) a[u.first][i + C] = u.second;
            }
        }

        while (total) {
            Ans[total].clear();
            total--;
        }

        A.init(n);

        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) vis[j] = 1;
            for (int j = 1; j <= R; j++) {
                vis[a[j][i]] = 0;
            }
            for (int j = 1; j <= n; j++) {
                if (vis[j]) {
                    A.add(i, j);
                }
            }
        }

        solve(A);

        for (int i = 1; i <= total; i++) {
            for (auto u : Ans[i]) {
                a[i + R][u.first] = u.second;
            }
        }

        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                write(a[i][j]);
                putchar(" \n"[j == n]);
            }
        }

        A.init(n);

        while (total) {
            Ans[total].clear();
            total--;
        }
    }
}