#include <cstdio>

 #include <cstring>

 #include <queue>

 #include <vector>

 using namespace std;

 /// 结点下标从0开始，注意maxn

 struct Dinic {

     static const int maxn =  + ;

     static const int INF = 0x3f3f3f3f;

     struct Edge {

         int from, to, cap, flow;

     };

     int n, m, s, t; // 结点数，边数（包括反向弧），源点编号和汇点编号

     vector<Edge> edges; // 边表。edges[e]和edges[e^1]互为反向弧

     vector<int> G[maxn]; // 邻接表，G[i][j]表示结点i的第j条边在e数组中的序号

     bool vis[maxn]; // BFS使用

     int d[maxn]; // 从起点到i的距离

     int cur[maxn]; // 当前弧下标

     void init(int n) {

         this->n = n;

         edges.clear();

         for(int i = ; i < n; i++) G[i].clear();

     }

     void AddEdge(int from, int to, int cap) {

         edges.push_back((Edge){from, to, cap, });

         edges.push_back((Edge){to, from, , });

         m = edges.size();

         G[from].push_back(m-);

         G[to].push_back(m-);

     }

     bool BFS() {

         memset(vis, , sizeof(vis));

         queue<int> Q;

         Q.push(s);

         vis[s] = ;

         d[s] = ;

         while(!Q.empty()) {

             int x = Q.front();  Q.pop();

             for(int i = ; i < G[x].size(); i++) {

                 Edge& e = edges[G[x][i]];

                 if(!vis[e.to] && e.cap > e.flow) { // 只考虑残量网络中的弧

                     vis[e.to] = ;

                     d[e.to] = d[x] + ;

                     Q.push(e.to);

                 }

             }

         }

         return vis[t];

     }

     int DFS(int x, int a) {

         if(x == t || a == ) return a;

         int flow = , f;

         for(int& i = cur[x]; i < G[x].size(); i++) { // 从上次考虑的弧

             Edge& e = edges[G[x][i]];

             if(d[x]+ == d[e.to] && (f=DFS(e.to, min(a, e.cap-e.flow))) > ) {

                 e.flow += f;

                 edges[G[x][i]^].flow -= f;

                 flow += f;

                 a -= f;

                 if(a == ) break;

             }

         }

         return flow;

     }

     int Maxflow(int s, int t) {

         this->s = s;  this->t = t;

         int flow = ;

         while(BFS()) {

             memset(cur, , sizeof(cur));

             flow += DFS(s, INF);

         }

         return flow;

     }

     vector<int> Mincut() { // 在Maxflow之后调用

         vector<int> ans;

         for(int i = ; i < edges.size(); i++) {

             Edge& e = edges[i];

             if(vis[e.from] && !vis[e.to] && e.cap > ) ans.push_back(i);

         }

         return ans;

     }

 };

 const int UP =  + ;

 int id[UP][UP];

 Dinic dc;

 int main() {

     int T, R, C;

     scanf("%d", &T);

     for(int cases = ; cases <= T; cases++) {

         scanf("%d%d", &R, &C);

         dc.init(R+C+);

         int start = R+C, finish = R+C+, last = ;

         for(int v, i = ; i < R; i++) {

             scanf("%d", &v);

             dc.AddEdge(start, i, v - last - C);

             last = v;

         }

         last = ;

         for(int v, i = ; i < C; i++) {

             scanf("%d", &v);

             dc.AddEdge(R+i, finish, v - last - R);

             last = v;

         }

         for(int r = ; r < R; r++) {

             for(int c = ; c < C; c++) {

                 dc.AddEdge(r, R+c, );

                 id[r][c] = dc.edges.size() - ;

             }

         }

         dc.Maxflow(start, finish);

         printf("Matrix %d\n", cases);

         for(int r = ; r < R; r++) {

             for(int c = ; c < C; c++) {

                 printf("%d ", dc.edges[id[r][c]].flow + );

             }

             printf("\n");

         }

         printf("\n");

     }

     return ;

 }