#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <cstdio>
#include <cstring>
using namespace std;

const int INF = 1 << 15;
const int MAXN = 200 + 25;
struct Edge{
   int from,to,cap,flow,cost;
   Edge(){};
   Edge(int _from,int _to,int _cap,int _flow)
       :from(_from),to(_to),cap(_cap),flow(_flow){};
};
vector<Edge> edges;
vector<int> G[MAXN];
int cur[MAXN],d[MAXN];
bool vst[MAXN];
int N,M,src,sink;
int tt,ss;
int in[MAXN];
int B[MAXN][MAXN],C[MAXN][MAXN];
int ans[MAXN][MAXN];
bool flag;
void init(){
    ss = N + M + 1; tt = ss + 1;
    src = tt + 1; sink = src + 1;

    for(int i = 0;i <= sink;++i)
        G[i].clear();
    edges.clear();
}
inline void addEdge(int from,int to,int cap){
    edges.push_back(Edge(from,to,cap,0));
    edges.push_back(Edge(to,from,0,0));
    int sz = edges.size();
    G[from].push_back(sz - 2);
    G[to].push_back(sz - 1);
}
inline void input(int x,int y,char *ope,int c){
    int x1,x2,y1,y2;
    x1 = x2 = x;
    y1 = y2 = y;
    if(!x) x1 = 1,x2 = N;
    if(!y) y1 = 1,y2 = M;
    for(int i = x1;i <= x2;++i){
        for(int j = y1;j <= y2;++j){
            if(ope[0] == '=')
                B[i][j] = C[i][j] = c;
            else if(ope[0] == '>')
                B[i][j] = max(B[i][j],c + 1);
            else
                C[i][j] = min(C[i][j],c - 1);
            if(C[i][j] < B[i][j])
                flag = false;
        }
    }
}
bool BFS(){
   memset(vst,0,sizeof(vst));
   queue<int> Q;
   Q.push(src);
   d[src] = 0;
   vst[src] = 1;

   while(!Q.empty()){
       int x = Q.front(); Q.pop();

       for(int i = 0;i < (int)G[x].size();++i){
          Edge& e = edges[G[x][i]];
          if(!vst[e.to] && e.cap > e.flow){
              d[e.to] = d[x] + 1;
              vst[e.to] = 1;
              Q.push(e.to);
          }
       }
   }

   return vst[sink];
}

int DFS(int x,int a){
    if(x == sink||a == 0)
        return a;

    int flow = 0,f;
    for(int& i = cur[x];i < (int)G[x].size();++i){
        Edge& e = edges[G[x][i]];
        if(d[e.to] == d[x] + 1&&(f = DFS(e.to,min(a,e.cap - e.flow))) > 0){
            e.flow += f;
            edges[G[x][i]^1].flow -= f;
            flow += f;
            a -= f;
            if(a == 0) break;
        }
    }

    return flow;
}



int maxFlow(){
   int flow = 0;
   while(BFS()){
       memset(cur,0,sizeof(cur));
       flow += DFS(src,INF);
   }
   return flow;
}


int main()
{
   // freopen("Input.txt","r",stdin);

    int T;
    scanf("%d",&T);
    while(T--){
        char ope[3];
        int x,y,c;

        scanf("%d%d",&N,&M);

        init();
        memset(in,0,sizeof(in));

        for(int i = 1;i <= N;++i){
            for(int j = 1;j <= M;++j){
                B[i][j] = 0;
                C[i][j] = INF;
            }
        }

        for(int i = 1;i <= N;++i){   //行
            scanf("%d",&c);

            addEdge(ss,i,0);
            in[ss] -= c;
            in[i] += c;
        }

        for(int j = 1;j <= M;++j){  //列
            scanf("%d",&c);

            addEdge(j+N,tt,0);
            in[j + N] -= c;
            in[tt] += c;
        }

        int cas;
        scanf("%d",&cas);
        while(cas--){
            scanf("%d%d%s%d",&x,&y,ope,&c);
            input(x,y,ope,c);
        }

        if(flag){
            puts("IMPOSSIBLE\n");
            continue;
        }

         //建图
        for(int i = 1;i <= N;++i){
            for(int j = 1;j <= M;++j){
                addEdge(i,j + N,C[i][j] - B[i][j]);
                in[i] -= B[i][j];
                in[j+N] += B[i][j];
            }
        }

        int sum = 0;
        for(int i = 1;i <= tt;++i){
            if(in[i] > 0){
               sum += in[i];
               addEdge(src,i,in[i]);
            }
            if(in[i] < 0){
               addEdge(i,sink,-in[i]);
            }
        }

        addEdge(tt,ss,INF);            int flow = maxFlow();
        if(flow != sum){
            puts("IMPOSSIBLE");
        } else {
           maxFlow();
           for(int i = 1;i <= N;++i){
                for(int j = 0;j < (int)G[i].size();++j){
                    Edge& e = edges[G[i][j]];
                    if(N < e.to && e.to < ss)
                        ans[e.from][e.to - N] = e.flow + B[e.from][e.to - N];
                }
            }

            for(int i = 1;i <= N;++i){
                for(int j = 1;j <= M;++j){
                    printf("%d ",ans[i][j]);
                }
                puts("");
            }
        }
        puts("");
    }
    return 0;
}