#include <bits/stdc++.h>
#define ms(x, v) memset(x, v, sizeof(x))
#define il __attribute__((always_inline)) static
#define U(i,l,r) for(int i(l),END##i(r);i<=END##i;++i)
#define D(i,r,l) for(int i(r),END##i(l);i>=END##i;--i)
using namespace std;
using ll = long long;

#define IC isdigit(c)
#define GC c=getchar()
void rd(auto &x) { x = 0; char GC; bool f = 0;
	for (; !IC; GC) f |= c == '-';
	for (; IC; GC) x = x * 10 + c - 48;
	if (f) x = -x;
}
void rd(auto &x, auto &...y) { rd(x); rd(y...); }
#define meow(...) fprintf(stderr, __VA_ARGS__)
#define Assert(e, v) if (!(e)) exit(v);

#define int ll

// f(i,j) 当前第一个串是 i, 第二个串长度少了 j, 0/1 是否有交错 :: 最小的串长
// 最段路转移，枚举一个串拼上，n^2 条边
// 每个点被更新的次数 <= 这个点的最短路

const int N = 1005, M = N * 40, INF = 0x3f3f3f3f3f3f3f3f;
namespace MCMF {
	int s, t;
	
	// vector<tuple<int, int, int, int>> egs;
	int tail[N];
	struct Edge { int v, flow, dis, pre; } g[M << 1]; int ep = 1;
	void add(int u, int v, int flow, int dis) {
		// clog << u << ' ' << v << ' ' << flow << ' ' << dis << endl;
		g[++ep] = { v, flow, dis, tail[u] };
		tail[u] = ep;
	}
	void create(int u, int v, int f, int d) {
		add(u, v, f, d);
		// egs.emplace_back(u, v, f, ep);
		add(v, u, 0, -d); // 无向图最小割
		clog << u << ' ' << v << ' ' << f << endl;
		// clog << u << ' ' << v << ' ' << f << ' ' << d << endl;
	}
	// void print() {
	// 	for (auto [u, v, f, p] : egs) {
	// 		clog << u << ' ' << v << ' ' << g[p ^ 1].flow
	// 			<< "[" << f << "]" << endl;
	// 	}
	// }
	
	int pre[N], te[N];
	bool spfa() {
		static bool vis[N]; memset(vis, 0, sizeof(vis));
		static int dis[N]; memset(dis, 0x3f, sizeof(dis));
		queue<int> q; vis[s] = true; q.push(s); dis[s] = pre[s] = te[s] = 0;
		while (q.size()) {
			int u = q.front(); q.pop();
			vis[u] = false;
			for (int p = tail[u]; p; p = g[p].pre) {
				const Edge& e = g[p];
				if (e.flow && dis[e.v] > dis[u] + e.dis) {
					dis[e.v] = dis[u] + e.dis;
					pre[e.v] = u; te[e.v] = p;
					if (!vis[e.v]) {
						vis[e.v] = true;
						q.push(e.v);
					}
				}
			}
		}
		// clog << dis[t] << '\t';
		return dis[t] != INF;
	}
	void MCMF(int& f, int& c) {
		f = c = 0;
		while (spfa()) {

			int cf = INF, cc = 0;
			int u = t;
			while (u != s) {
				cf = min(cf, g[te[u]].flow);
				u = pre[u];
			}
			u = t;
			while (u != s) {
				cc += cf * g[te[u]].dis;
				g[te[u]].flow -= cf;
				g[te[u] ^ 1].flow += cf;
				u = pre[u];
			}
			
			f += cf; c += cc;
		}
	}

	int layer[N];
	bool bfs() {
		ms(layer, 0);
		queue<int> q; q.push(s); layer[s] = 1;
		while (q.size()) {
			int u = q.front(); q.pop();
			for (int p = tail[u]; p; p = g[p].pre) if (g[p].flow) {
				int v = g[p].v;
				if (!layer[v]) {
					layer[v] = layer[u] + 1;
					q.push(v);
				}
			}
		}
		return layer[t];
	}
	ll dinic(int u, ll f) {
		if (!f) return 0;
		if (u == t) return f;
		ll tot = 0;
		for (int p = tail[u]; p; p = g[p].pre) {
			tail[u] = p;
			ll x; int v = g[p].v;
			if (layer[v] == layer[u] + 1 && (x = dinic(v, min(f, g[p].flow)))) {
				g[p].flow -= x;
				g[p ^ 1].flow += x;
				tot += x;
				f -= x;
				if (!f)
					break;
			}
		}
		return tot;
	}
	ll flow() {
		int org[N]; memcpy(org, tail, sizeof(tail));
		ll f = 0;
		while (bfs()) {
			ll x = dinic(s, INF);
			f += x;
			memcpy(tail, org, sizeof(org));
			// clog << f << endl;
		}
		return f;
	}

	void clear() {
		ms(tail, 0);
		ms(g, 0);
		ep = 1;
	}
};
using MCMF::create, MCMF::s, MCMF::t;

int n, m, k;

signed main() {
	// freopen("arrebol.in", "r", stdin);
	// freopen("arrebol.out", "w", stdout);

	int T; rd(T);
	while (T--) {
		s = N - 1, t = s - 1;

		rd(n, m, k);
		int id[n + 3][m + 3] {}, ptr = 0;
		U (i, 0, n + 2) U (j, 0, m + 2) id[i][j] = -1919810;
		U (i, 1, n + 1) U (j, 1, m + 1)
			id[i][j] = ++ptr;
		int rW[n + 1][m + 1] {}, cW[n + 1][m + 1] {};
		U (i, 1, n) U (j, 2, m) {
			int &w = rW[i][j]; rd(w);
			create(id[i][j], id[i + 1][j], w, 0);
			create(id[i + 1][j], id[i][j], w, 0);
		}
		U (i, 2, n) U (j, 1, m) {
			int &w = cW[i][j]; rd(w);
			create(id[i][j], id[i][j + 1], w, 0);
			create(id[i][j + 1], id[i][j], w, 0);
		}
		U (j, 1, m) {
			create(id[1][j], id[1][j + 1], INF, 0),
			create(id[1][j + 1], id[1][j], INF, 0);
			create(id[n + 1][j], id[n + 1][j + 1], INF, 0),
			create(id[n + 1][j + 1], id[n + 1][j], INF, 0);
		}
		// U (i, 1, n)
		// 	create(id[i][1], id[i + 1][1], 0, 0),
		// 	create(id[i][m + 1], id[i + 1][m + 1], 0, 0);
		create(s, id[1][1], INF, 0);
		create(id[n + 1][m + 1], t, INF, 0);

		int flow, cost;
		flow = MCMF::flow();
		// clog << endl << endl;
		// MCMF::print();
		clog << flow << endl;

		MCMF::add(t, t - 1, k, 0);
		MCMF::add(t - 1, t, flow, 0);
		--t;

		int rE[n + 3][m + 3][2] {}, cE[n + 3][m + 3][2] {};
		U (i, 1, n) U (j, 2, m) {
			create(id[i][j], id[i + 1][j], INF, 1);
			rE[i][j][0] = MCMF::ep;
			create(id[i + 1][j], id[i][j], INF, 1);
			rE[i][j][1] = MCMF::ep;
			// rE[i][j] = MCMF::ep;
		}
		U (i, 2, n) U (j, 1, m) {
			create(id[i][j], id[i][j + 1], INF, 1);
			cE[i][j][0] = MCMF::ep;
			create(id[i][j + 1], id[i][j], INF, 1);
			cE[i][j][1] = MCMF::ep;
		}

		MCMF::MCMF(flow, cost);
		// MCMF::flow();
		
		cout << cost << endl;
		U (i, 1, n) U (j, 2, m) {
			int res = rW[i][j] + MCMF::g[rE[i][j][0]].flow + MCMF::g[rE[i][j][1]].flow;
			cout << res << (j == m ? '\n' : ' ');
		}
		U (i, 2, n) U (j, 1, m) {
			int res = cW[i][j] + MCMF::g[cE[i][j][0]].flow + MCMF::g[cE[i][j][1]].flow;
			cout << res << (j == m ? '\n' : ' ');
		}

		MCMF::clear();
	}
}