#include <bits/stdc++.h>
using namespace std;

#define all(x) begin(x), end(x)
#ifdef CKISEKI
#define safe cerr << __PRETTY_FUNCTION__ << " line " << __LINE__ << " safe\n"
#define orange(a...) orange_(#a, a)
#define debug(a...) debug_(#a, a)
#include <experimental/iterator>
void debug_(auto s, auto ...a) {
  cerr << "\e[1;32m(" << s << ") = (";
  int f = 0;
  (..., (cerr << (f++ ? ", " : "") << a));
  cerr << ")\e[0m\n";
}
void orange_(auto s, auto L, auto R) {
  cerr << "\e[1;33m[ " << s << " ] = [ ";
  using namespace experimental;
  copy(L, R, make_ostream_joiner(cerr, ", "));
  cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define debug(...) safe
#define orange(...) safe
#endif

constexpr int N = 100000;
constexpr int M = 100000;

using ll = int64_t;

int vis[N], visc, fa[N], fae[N], head[N], mlc = 1;

struct ep {
  int to, next;
  ll flow, cost;
} e[M << 1];

void adde(int u, int v, ll fl, int cs) {
  e[++mlc] = {v, head[u], fl, cs};
  head[u] = mlc;
  e[++mlc] = {u, head[v], 0, -cs};
  head[v] = mlc;
}

void dfs(int u) {
  vis[u] = 1;
  for (int i = head[u], v; i; i = e[i].next)
    if (!vis[v = e[i].to] and e[i].flow)
      fa[v] = u, fae[v] = i, dfs(v);
}

ll phi(int x) {
  static ll pi[N];
  if (x == -1)
    return 0;
  if (vis[x] == visc)
    return pi[x];
  return vis[x] = visc, pi[x] = phi(fa[x]) - e[fae[x]].cost;
}

void pushflow(int x, ll &cost) {
  int v = e[x ^ 1].to, u = e[x].to;
  ++visc;
  while (v != -1)
    vis[v] = visc, v = fa[v];
  while (u != -1 && vis[u] != visc)
    vis[u] = visc, u = fa[u];
  vector<int> cyc;
  int e2 = 0, pa = 2;
  ll f = e[x].flow;
  for (int i = e[x ^ 1].to; i != u; i = fa[i]) {
    cyc.push_back(fae[i]);
    if (e[fae[i]].flow < f)
      f = e[fae[e2 = i] ^ (pa = 0)].flow;
  }
  for (int i = e[x].to; i != u; i = fa[i]) {
    cyc.push_back(fae[i] ^ 1);
    if (e[fae[i] ^ 1].flow < f)
      f = e[fae[e2 = i] ^ (pa = 1)].flow;
  }
  cyc.push_back(x);
  for (int cyc_i : cyc) {
    e[cyc_i].flow -= f, e[cyc_i ^ 1].flow += f;
    cost += 1ll * f * e[cyc_i].cost;
  }
  if (pa == 2) return;
  int le = x ^ pa, l = e[le].to, o = e[le ^ 1].to;
  while (l != e2) {
    vis[o] = 0;
    swap(le ^= 1, fae[o]), swap(l, fa[o]), swap(l, o);
  }
}

ll simplex() {
  ll cost = 0;
  memset(fa, -1, sizeof(fa)), dfs(1);
  vis[1] = visc = 2, fa[1] = -1;
  for (int i = 2, pre = -1; i != pre; i = (i == mlc ? 2 : i + 1))
    if (e[i].flow and e[i].cost < phi(e[i ^ 1].to) - phi(e[i].to))
      pushflow(pre = i, cost);
  return cost;
}

void solve() {
  int n, m, k;
  cin >> n >> m >> k;

  visc = 0;
  mlc = 1;
  fill_n(vis, n * m + 3, 0);
  fill_n(fa, n * m + 3, 0);
  fill_n(fae, n * m + 3, 0);
  fill_n(head, n * m + 3, 0);

  const int S = n * m + 1, T = n * m + 2;

  vector<array<int, 3>> es;
  auto add_edge = [&es](int u, int v, int w) {
    adde(u, v, w, 0);
    es.push_back({u, v, w});
  };

  vector<vector<array<int, 3>>> hori;
  for (int i = 0; i < n; ++i) {
    vector<array<int, 3>> cur;
    for (int j = 1; j < m; ++j) {
      int x;
      cin >> x;
      if (i == 0) {
        add_edge(S, i * (m - 1) + (j - 1) + 1, x);
        cur.push_back({x, mlc, -1});
      } else if (i == n - 1) {
        add_edge((i - 1) * (m - 1) + (j - 1) + 1, T, x);
        cur.push_back({x, mlc, -1});
      } else {
        int up = (i - 1) * (m - 1) + (j - 1) + 1;
        int down = i * (m - 1) + (j - 1) + 1;
        add_edge(up, down, x);
        int m1 = mlc;
        add_edge(down, up, x);
        cur.push_back({x, m1, mlc});
      }
    }
    hori.push_back(cur);
  }

  vector<vector<array<int, 3>>> vert;
  for (int i = 1; i < n; ++i) {
    vector<array<int, 3>> cur;
    for (int j = 0; j < m; ++j) {
      int x;
      cin >> x;
      if (j == 0 or j == m - 1) {
        cur.push_back({x, -1, -1});
      } else {
        int lhs = (i - 1) * (m - 1) + (j - 1) + 1;
        int rhs = (i - 1) * (m - 1) + j + 1;
        add_edge(lhs, rhs, x);
        int m1 = mlc;
        add_edge(rhs, lhs, x);
        cur.push_back({x, m1, mlc});
      }
    }
    vert.push_back(cur);
  }
  adde(T, S, 1e14, -1);
  ll mf = simplex();

  visc = 0;
  mlc = 1;
  fill_n(vis, n * m + 3, 0);
  fill_n(fa, n * m + 3, 0);
  fill_n(fae, n * m + 3, 0);
  fill_n(head, n * m + 3, 0);

  for (auto [u, v, w] : es) {
    adde(u, v, k, 1);
  }
  for (auto [u, v, w] : es) {
    adde(u, v, w, 0);
  }
  adde(T, S, k - mf, -1e9);
  ll ans = simplex() + (k - mf) * ll(1e9);
  cout << ans << '\n';
  for (int i = 0; i < n; ++i) {
    for (int j = 1; j < m; ++j) {
      if (i == 0) {
        cout << hori[i][j - 1][0] + e[hori[i][j - 1][1]].flow;
      } else if (i == n - 1) {
        cout << hori[i][j - 1][0] + e[hori[i][j - 1][1]].flow;
      } else {
        cout << hori[i][j - 1][0] + max(e[hori[i][j - 1][1]].flow, e[hori[i][j - 1][2]].flow);
      }
      cout << " \n"[j + 1 == m];
    }
  }
  for (int i = 1; i < n; ++i) {
    for (int j = 0; j < m; ++j) {
      if (j == 0 or j == m - 1) {
        cout << vert[i - 1][j][0];
      } else {
        cout << vert[i - 1][j][0] + max(e[vert[i - 1][j][1]].flow, e[vert[i - 1][j][2]].flow);
      }
      cout << " \n"[j + 1 == m];
    }
  }
}

int main() {
  cin.tie(nullptr)->sync_with_stdio(false);
  int t;
  cin >> t;
  while (t--) {
    solve();
  }
  return 0;
}