#include <bits/stdc++.h>
#define FileIO_(file) \
	freopen (file ".in", "r", stdin); \
	freopen (file ".out", "w", stdout);

using namespace std;

template<typename Tp>
inline void chmin (Tp &x, const Tp &y) { if (x > y) x = y; }
template<typename Tp>
inline void chmax (Tp &x, const Tp &y) { if (x < y) x = y; }

typedef double dbl;
typedef long long ll;
typedef long double ldb;
const int maxnm = 5e2 + 20;

void init () {}

namespace Dinic {

const int maxvcnt = maxnm * maxnm;
const int maxecnt = 2 * 3 * maxnm * maxnm;
const ll lnf = 0x3f3f3f3f3f3f3f3f;
int s, t, ecnt, h[maxvcnt], cur[maxvcnt];
ll dis[maxvcnt];
bool vis[maxvcnt];

struct Data {
	ll w, c;
	void operator+= (const Data &oth) {
		w += oth.w; c += oth.c;
	}
};

struct Edge {
	Data d; int to, nxt;
} e[maxecnt];

void init (int s, int t) {
	Dinic::s = s; Dinic::t = t; ecnt = 0;
	memset (h, ~0, sizeof (h));
}

int addEdge (int u, int v, const Data &d) {
	e[ecnt] = {d, v, h[u]}; return h[u] = ecnt++;
}

int link (int u, int v, ll w, ll c) {
	addEdge (v, u, {c ? 0 : w, -c});
	return addEdge (u, v, {w, c});
}

bool bfs () {
	memcpy (cur, h, sizeof (cur));
	memset (dis, ~0, sizeof (dis));
	queue<int, list<int> > q;
	dis[s] = 0; q.emplace (s);
	
	while (!q.empty ()) {
		int u = q.front (); q.pop ();
		
		for (int i = h[u]; ~i; i = e[i].nxt) {
			int v = e[i].to;
			if (e[i].d.w && !~dis[v]) {
				dis[v] = dis[u] + 1;
				q.emplace (v);
			}
		}
	}
	
	return ~dis[t];
}

bool spfa () {
	memcpy (cur, h, sizeof (cur));
	memset (vis, 0, sizeof (vis));
	memset (dis, 0x3f, sizeof (dis));
	queue<int, list<int> > q;
	dis[s] = 0; q.emplace (s);
	
	while (!q.empty ()) {
		int u = q.front (); q.pop (); vis[u] = 0;
		
		for (int i = h[u]; ~i; i = e[i].nxt) {
			int v = e[i].to;
			if (e[i].d.w) {
				ll nd = dis[u] + e[i].d.c;
				if (nd < dis[v]) {
					dis[v] = nd;
					if (!vis[v]) {
						vis[v] = 1;
						q.emplace (v);
					}
				}
			}
		}
	}
	
	return dis[t] != lnf;
}

ll dfsFlow (int u, ll flow) {
	if (u == t) return flow;
	
	ll res = 0;
	
	for (int &i = cur[u]; ~i; i = e[i].nxt) {
		int v = e[i].to; ll &w = e[i].d.w;
		if (v != t && (!w || dis[v] != dis[u] + 1)) continue;
		ll ext = dfsFlow (v, min (w, flow - res));
		w -= ext; e[i ^ 1].d.w += ext; res += ext;
		if (res == flow) break;
	}
	
	return res;
}

Data dfsCost (int u, ll flow) {
	vis[u] = 1;
	
	if (u == t) return {flow, 0};
	
	Data res = {0, 0};
	
	for (int &i = cur[u]; ~i; i = e[i].nxt) {
		int v = e[i].to; ll &w = e[i].d.w, c = e[i].d.c;
		if (!w || dis[v] != dis[u] + c || (v != t && vis[v])) continue;
		Data ext = dfsCost (v, min (w, flow - res.w));
		w -= ext.w; e[i ^ 1].d.w += ext.w;
		res += {ext.w, ext.c + ext.w * c};
		if (res.w == flow) break;
	}
	
	return res;
}

ll workFlow () {
	ll res = 0;
	while (bfs ())
		res += dfsFlow (s, lnf);
	return res;
}

Data workCost () {
	Data res = {0, 0};
	while (spfa ()) do {
		memset (vis, 0, sizeof (vis));
		res += dfsCost (s, lnf);
	} while (vis[t]);
	return res;
}

} // namespace Dinic

int n, m, k, vs, vu, vd, vl, vr;
int r[maxnm][maxnm], c[maxnm][maxnm];
ll er[maxnm][maxnm][2], ec[maxnm][maxnm][2];

int getId (int x, int y) {
	if (x <= 0) return vu;
	if (x >= n) return vd;
	if (y <= 0) return vl;
	if (y >= m) return vr;
	return (x - 1) * m + y;
}

void solve () {
	scanf ("%d%d%d", &n, &m, &k);
	
	vs = n * m;
	vu = n * m + 1; vd = n * m + 2;
	vl = n * m + 3; vr = n * m + 4;
	
	Dinic::init (vu, vd);

	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j < m; ++j) {
			scanf ("%d", &r[i][j]);
			Dinic::link (
				getId (i - 1, j),
				getId (i, j),
				r[i][j], 0
			);
		}
	}
	
	for (int i = 1; i < n; ++i) {
		for (int j = 1; j <= m; ++j) {
			scanf ("%d", &c[i][j]);
			if (1 < j && j < m)
				Dinic::link (
					getId (i, j - 1),
					getId (i, j),
					c[i][j], 0
				);
		}
	}
	
	Dinic::workFlow ();
	Dinic::link (vs, Dinic::s, k, 0);
	Dinic::s = vs;

	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j < m; ++j) {
			er[i][j][0] = Dinic::link (
				getId (i - 1, j),
				getId (i, j),
				Dinic::lnf, 1
			);
			er[i][j][1] = Dinic::link (
				getId (i, j),
				getId (i - 1, j),
				Dinic::lnf, 1
			);
		}
	}
	
	for (int i = 1; i < n; ++i) {
		for (int j = 1; j <= m; ++j) {
			ec[i][j][0] = Dinic::link (
				getId (i, j - 1),
				getId (i, j),
				Dinic::lnf, 1
			);
			ec[i][j][1] = Dinic::link (
				getId (i, j),
				getId (i, j - 1),
				Dinic::lnf, 1
			);
		}
	}
	
	printf ("%lld\n", Dinic::workCost ().c);

	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j < m; ++j) {
			printf ("%lld%c", r[i][j] +
				(Dinic::lnf - Dinic::e[er[i][j][0]].d.w) +
				(Dinic::lnf - Dinic::e[er[i][j][1]].d.w),
				" \n"[j == m - 1]
			);
		}
	}
	
	for (int i = 1; i < n; ++i) {
		for (int j = 1; j <= m; ++j) {
			printf ("%lld%c", c[i][j] +
				(Dinic::lnf - Dinic::e[ec[i][j][0]].d.w) +
				(Dinic::lnf - Dinic::e[ec[i][j][1]].d.w),
				" \n"[j == m]
			);
		}
	}
}

int main () {
//	#ifndef LSY
//	FileIO_("");
//	#endif
	int t = 1; init ();
	scanf ("%d", &t);
	while (t--) solve ();
	return 0;
}