#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>

using namespace std;
typedef long long ll;

template <typename T> class flow_graph {
public:
  static constexpr T eps = (T)1e-9;

  struct edge {
    int to;
    T c;
    T f;
    int rev;
  };

  vector<vector<edge>> g;
  vector<int> ptr;
  vector<int> d;
  vector<int> q;
  int n;
  int st, fin;
  T flow;

  flow_graph(int _n, int _st, int _fin) : n(_n), st(_st), fin(_fin) {
    assert(0 <= st && st < n && 0 <= fin && fin < n && st != fin);
    g.resize(n);
    ptr.resize(n);
    d.resize(n);
    q.resize(n);
    flow = 0;
  }

  void clear_flow() {
    for (int i = 0; i < n; i++) {
      for (edge &e : g[i]) {
        e.f = 0;
      }
    }
    flow = 0;
  }

  void add(int from, int to, T forward_cap, T backward_cap) {
    assert(0 <= from && from < n && 0 <= to && to < n);
    int from_size = g[from].size();
    int to_size = g[to].size();
    g[from].push_back({to, forward_cap, 0, to_size});
    g[to].push_back({from, backward_cap, 0, from_size});
  }

  bool expath() {
    fill(d.begin(), d.end(), -1);
    q[0] = fin;
    d[fin] = 0;
    int beg = 0, end = 1;
    while (beg < end) {
      int i = q[beg++];
      for (const edge &e : g[i]) {
        const edge &back = g[e.to][e.rev];
        if (back.c - back.f > eps && d[e.to] == -1) {
          d[e.to] = d[i] + 1;
          if (e.to == st) {
            return true;
          }
          q[end++] = e.to;
        }
      }
    }
    return false;
  }

  T dfs(int v, T w) {
    if (v == fin) {
      return w;
    }
    int &j = ptr[v];
    while (j >= 0) {
      const edge &e = g[v][j];
      if (e.c - e.f > eps && d[e.to] == d[v] - 1) {
        T t = dfs(e.to, min(e.c - e.f, w));
        if (t > eps) {
          g[v][j].f += t;
          g[e.to][e.rev].f -= t;
          return t;
        }
      }
      j--;
    }
    return 0;
  }

  T max_flow() {
    while (expath()) {
      for (int i = 0; i < n; i++) {
        ptr[i] = (int)g[i].size() - 1;
      }
      T big_add = 0;
      while (true) {
        T add = dfs(st, numeric_limits<T>::max());
        if (add <= eps) {
          break;
        }
        big_add += add;
      }
      if (big_add <= eps) {
        break;
      }
      flow += big_add;
    }
    return flow;
  }

  vector<bool> min_cut() {
    max_flow();
    vector<bool> ret(n);
    for (int i = 0; i < n; i++) {
      ret[i] = (d[i] != -1);
    }
    return ret;
  }
};

template <typename T, typename C> class mcmf {
public:
  static constexpr T eps = (T)1e-9;

  struct edge {
    int from;
    int to;
    T c;
    T f;
    C cost;
  };

  vector<vector<int>> g;
  vector<edge> edges;
  vector<C> d;
  vector<int> q;
  vector<bool> in_queue;
  vector<int> pe;
  int n;
  int st, fin;
  T flow;
  C cost;

  mcmf(int _n, int _st, int _fin) : n(_n), st(_st), fin(_fin) {
    assert(0 <= st && st < n && 0 <= fin && fin < n && st != fin);
    g.resize(n);
    d.resize(n);
    in_queue.resize(n);
    pe.resize(n);
    flow = 0;
    cost = 0;
  }

  void clear_flow() {
    for (const edge &e : edges) {
      e.f = 0;
    }
    flow = 0;
  }

  void add_edge(int from, int to, T cap, T flow) {
    assert(0 <= from && from < n && 0 <= to && to < n);
    g[from].push_back((int)edges.size());
    edges.push_back({from, to, cap, flow, 0});
    g[to].push_back((int)edges.size());
    edges.push_back({to, from, cap, -flow, 0});
  }

  void add(int from, int to, T forward_cap, T backward_cap, C cost) {
    assert(0 <= from && from < n && 0 <= to && to < n);
    g[from].push_back((int)edges.size());
    edges.push_back({from, to, forward_cap, 0, cost});
    g[to].push_back((int)edges.size());
    edges.push_back({to, from, backward_cap, 0, -cost});
  }

  bool expath() {
    fill(d.begin(), d.end(), numeric_limits<C>::max());
    q.clear();
    q.push_back(st);
    d[st] = 0;
    in_queue[st] = true;
    int beg = 0;
    bool found = false;
    while (beg < (int)q.size()) {
      int i = q[beg++];
      if (i == fin) {
        found = true;
      }
      in_queue[i] = false;
      for (int id : g[i]) {
        const edge &e = edges[id];
        if (e.c - e.f > eps && d[i] + e.cost < d[e.to]) {
          d[e.to] = d[i] + e.cost;
          pe[e.to] = id;
          if (!in_queue[e.to]) {
            q.push_back(e.to);
            in_queue[e.to] = true;
          }
        }
      }
    }
    if (found) {
      T push = 1;
      int v = fin;
      while (v != st) {
        const edge &e = edges[pe[v]];
        push = min(push, e.c - e.f);
        v = e.from;
      }
      v = fin;
      while (v != st) {
        edge &e = edges[pe[v]];
        e.f += push;
        edge &back = edges[pe[v] ^ 1];
        back.f -= push;
        v = e.from;
      }
      flow += push;
      cost += push * d[fin];
    }
    return found;
  }

  pair<T, C> max_flow_min_cost() {
    while (expath()) {
    }
    return make_pair(flow, cost);
  }
  pair<T, C> k_iters(int k) {
    for (int i = 0; i < k; ++i) {
      assert(expath());
    }
    return make_pair(flow, cost);
  }
};

/*
2
3 4 6
2 1 15
7 1 9
13 3 2
3 6 1 2
5 2 15 3
3 3 3
1 1
2 2
3 3
1 1 1
2 2 2
*/

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  int t;
  cin >> t;
  while (t--) {
    int n, m, k;
    cin >> n >> m >> k;
    vector<vector<vector<int>>> ed(n, vector<vector<int>>(m, vector<int>(2)));
    for (int i = 0; i < n; ++i) {
      for (int j = 0; j < m - 1; ++j) {
        cin >> ed[i][j][1];
      }
    }
    for (int i = 0; i < n - 1; ++i) {
      for (int j = 0; j < m; ++j) {
        cin >> ed[i][j][0];
      }
    }
    int nrows = n - 1, ncols = m - 1;
    int s = nrows * ncols, t = s + 1;
    int num_ver = t + 1;
    flow_graph<int> g(num_ver, s, t);
    for (int i = 0; i < m - 1; ++i) {
      g.add(s, i, ed[0][i][1], ed[0][i][1]);
      g.add((nrows - 1) * ncols + i, t, ed[nrows][i][1], ed[nrows][i][1]);
    }
    for (int i = 0; i < nrows; ++i) {
      for (int j = 0; j < ncols; ++j) {
        if (i + 1 < nrows) {
          g.add(i * ncols + j, (i + 1) * ncols + j, ed[i + 1][j][1],
                ed[i + 1][j][1]);
        }
        if (j + 1 < ncols) {
          g.add(i * ncols + j, i * ncols + (j + 1), ed[i][j + 1][0],
                ed[i][j + 1][0]);
        }
      }
    }
    g.max_flow();
    mcmf<int, int> cg(num_ver, s, t);
    for (int i = 0; i < num_ver; ++i) {
      for (auto edge : g.g[i]) {
        if (i < edge.to) {
          cg.add_edge(i, edge.to, edge.c, edge.f);
        }
      }
    }
    for (int i = 0; i < m - 1; ++i) {
      cg.add(s, i, k, 0, 1);
      cg.add((nrows - 1) * ncols + i, t, k, 0, 1);
    }
    for (int i = 0; i < nrows; ++i) {
      for (int j = 0; j < ncols; ++j) {
        if (i + 1 < nrows) {
          cg.add(i * ncols + j, (i + 1) * ncols + j, k, 0, 1);
          cg.add((i + 1) * ncols + j, i * ncols + j, k, 0, 1);
        }
        if (j + 1 < ncols) {
          cg.add(i * ncols + j, i * ncols + (j + 1), k, 0, 1);
          cg.add(i * ncols + (j + 1), i * ncols + j, k, 0, 1);
        }
      }
    }
    int ans = cg.k_iters(k).second;
    cout << ans << '\n';
    vector<vector<vector<int>>> ned = ed;
    for (auto edge : cg.edges) {
      if (edge.cost == 1 && edge.f > 0) {
        int u = edge.from, v = edge.to;
        if (u == s) {
          ned[0][v][1] += edge.f;
        } else if (v == t) {
          ned[nrows][u % ncols][1] += edge.f;
        } else {
          int iu = u / ncols, ju = u % ncols;
          int iv = v / ncols, jv = v % ncols;
          if (make_pair(iu, ju) > make_pair(iv, jv)) {
            swap(iu, iv);
            swap(ju, jv);
          }
          if (iu + 1 == iv) {
            assert(ju == jv);
            ned[iu + 1][ju][1] += edge.f;
          } else if (ju + 1 == jv) {
            assert(iu == iv);
            ned[iu][ju + 1][0] += edge.f;
          } else {
            assert(false);
          }
        }
      }
    }
    for (int i = 0; i < n; ++i) {
      for (int j = 0; j < m - 1; ++j) {
        cout << ned[i][j][1] << ' ';
      }
      cout << '\n';
    }
    for (int i = 0; i < n - 1; ++i) {
      for (int j = 0; j < m; ++j) {
        cout << ned[i][j][0] << ' ';
      }
      cout << '\n';
    }
  }
}