#include <bits/stdc++.h>

#define rep(i,s,n) for(int i = int(s); i < int(n); i++)
#define rrep(i,s,n) for(int i = int(n) - 1; i >= int(s); i--)
#define all(v) (v).begin(), (v).end()

using ll = long long;
using ull = unsigned long long;
using ld = long double;

bool chmin(auto &a, auto b) {
    if(a <= b) return false;
    a = b;
    return true;
}

bool chmax(auto &a, auto b) {
    if(a >= b) return false;
    a = b;
    return true;
}

using namespace std;

template <typename fa> struct FordFulkerson {
    struct edge{
        int to;
        fa cap;
        int rev;
        bool isrev;
    };
    const fa INF;
    vector<vector<edge>> g;
    vector<int> used;
    int ts;
    explicit FordFulkerson(int v): INF(numeric_limits<fa>::max()), g(v), used(v,-1), ts(0){}
    void add_edge(int from,int to, fa cap){
        g[from].push_back((edge){to,cap,(int)g[to].size(),false});
        g[to].push_back((edge){from,0,(int)g[from].size()-1,true});
    }
    fa dfs(int v,int t,fa flow){
        if(v==t)return flow;
        used[v]=ts;
        for (auto &e:g[v]){
            if (e.cap>0 && used[e.to]!=ts){
                fa d = dfs(e.to, t, min(flow,e.cap));
                if (d>0){
                    e.cap -= d;
                    g[e.to][e.rev].cap += d;
                    return d;
                }
            }
        }
        return 0;
    }
    fa flow(int s, int t){
        fa ret = 0;
        for (fa f; (f=dfs(s,t,INF))>0; ts++) ret+=f;
        ts++;
        return ret;
    }
};

const ll INF = std::numeric_limits<ll>::max() / 4;
const std::vector<int> dy = {1, 0, -1, 0}, dx = {0, 1, 0, -1};

using namespace std;
using P = std::pair<ll, int>;

vector<vector<ll>> dijk(int n, int m, vector<vector<ll>> &r, vector<vector<ll>> &c){
    std::priority_queue<P, std::vector<P>, std::greater<P>> pq;
    std::vector dp(n, std::vector<ll>(m, INF));
    rep(i,0,n) {
        dp[i][0] = 0;
        pq.push({0, i * m});
    }
    while(!pq.empty()) {
        auto [ret, v] = pq.top();
        pq.pop();
        int y = v / m, x = v % m;
        if(dp[y][x] < ret) continue;
        if (y < n-1){
            if (chmin(dp[y+1][x], c[y][x] + dp[y][x])){
                pq.push(pair(dp[y+1][x], (y+1)*m+x));
            }
        }
        if (y > 0){
            if (chmin(dp[y-1][x], c[y-1][x] + dp[y][x])){
                pq.push(pair(dp[y-1][x], (y-1)*m+x));
            }
        }
        if (x < m-1){
            if (chmin(dp[y][x+1], r[y][x] + dp[y][x])){
                pq.push(pair(dp[y][x+1], y*m+x+1));
            }
        }
        if (x > 0){
            if (chmin(dp[y][x-1], r[y][x-1] + dp[y][x])){
                pq.push(pair(dp[y][x-1], y*m+x-1));
            }
        }
    }
    return dp;
}

void solve() {
    int n,m;
    std::cin >> n >> m;
    int k; cin >> k;
    std::vector r(n, std::vector<ll>(m-1));
    std::vector c(n-1, std::vector<ll>(m));
    rep(i,0,n) rep(j,0,m-1) {
        std::cin >> r[i][j];
    }
    rep(i,0,n-1) rep(j,0,m) {
        std::cin >> c[i][j];
    }

    ll ans = 0;

    while(k--){
        vector<vector<ll>> a = dijk(n, m, r, c);    
        FordFulkerson<int> ff(n*m + 2);
        ll mx = 1e18;
        rep(i,0,n){
            chmin(mx, a[i][m-1]);
        }

        rep(i,0,n){
            ff.add_edge(n*m, i*m, 3000);
            if(a[i][m-1] == mx) ff.add_edge(i*m + m-1, n*m+1, 3000);
        }
        rep(i,0,n){
            rep(j,0,m-1){
                if (a[i][j+1] == a[i][j] + r[i][j]){
                    ff.add_edge(i*m+j, i*m+j+1, 1);
                }
                if (a[i][j] == a[i][j+1] + r[i][j]){
                    ff.add_edge(i*m+j+1, i*m+j, 1);
                }
            }
        }
        rep(i,0,n-1){
            rep(j,0,m){
                if (a[i+1][j] == a[i][j] + c[i][j]){
                    ff.add_edge(i*m+j, i*m+j+m, 1);
                }
                if (a[i][j] == a[i+1][j] + c[i][j]){
                    ff.add_edge(i*m+j+m, i*m+j, 1);
                }
            }
        }
        
        int v = ff.flow(n*m, n*m+1);
        ans += v;

        vector ikeru(n*m + 2, vector<int>(0));

        rep(i,0,n*m + 2){
            for (auto e: ff.g[i]){
                if (e.cap == 0) continue;
                ikeru[i].push_back(e.to);
            }
        }

        vector<int> mada = {n*m};
        vector<bool> tansaku(n*m+2);
        tansaku[n*m] = 1;
        while(!mada.empty()){
            int i = mada.back();
            mada.pop_back();
            for (int j: ikeru[i]){
                if (tansaku[j]) continue;
                tansaku[j] = 1;
                mada.push_back(j);
            }
        }
        rep(i,0,n){
            rep(j,0,m-1){
                if (tansaku[i*m+j] && !tansaku[i*m+j+1] && a[i][j+1] == a[i][j] + r[i][j]){
                    r[i][j]++;
                }
                if (!tansaku[i*m+j] && tansaku[i*m+j+1] && a[i][j] == a[i][j+1] + r[i][j]){
                    r[i][j]++;
                }
            }
        }

        rep(i,0,n-1){
            rep(j,0,m){
                if (tansaku[i*m+j] && !tansaku[i*m+j+m] && a[i+1][j] == a[i][j] + c[i][j]){
                    c[i][j]++;
                }
                if (!tansaku[i*m+j] && tansaku[i*m+j+m] && a[i][j] == a[i+1][j] + c[i][j]){
                    c[i][j]++;
                }
            }
        }
    }
    cout << ans << '\n';
    rep(i,0,n){
        rep(j,0,m-1){
            cout << r[i][j];
            if (j == m-2) cout << '\n';
            else cout << ' ';
        }
    }
    rep(i,0,n-1){
        rep(j,0,m){
            cout << c[i][j];
            if (j == m-1) cout << '\n';
            else cout << ' ';
        }
    }
}

int main() {
    std::cin.tie(nullptr);
    std::ios::sync_with_stdio(false);
    int t;
    std::cin >> t;
    while(t--) {
        solve();
    }
}