#include <iostream>

 #include <cstring>

 #include <algorithm>

 #include <cstdio>

 #include <cmath>

 #include <cstdlib>

 #include <cassert>

 #include <cctype>

 #include <queue>

 using namespace std;

 const int MAXN = ;

 const int INF = 0x3f3f3f3f;

 int n, sch[MAXN], home[MAXN];

 template< int MAXN, int MAXSZ >

 struct List {

     int head[MAXN], nxt[MAXSZ], val[MAXSZ], lidx;

     List() { clear(); }

     void clear() {

         lidx = ;

         memset( head, -, sizeof(head) );

     }

     void ins( int n, int v ) {

         val[lidx] = v; nxt[lidx] = head[n]; head[n] = lidx++;

     }

 };

 template< int MAXV, int MAXE >

 struct Dinic {

     struct Edge {

         int from, to, cap, flow;

         Edge(){}

         Edge( int from, int to, int cap, int flow ):

             from(from),to(to),cap(cap),flow(flow){}

     }edge[MAXE<<]; int eidx;

     int s, t;

     List<MAXV,MAXE<<> lst;

     Dinic() { init(); }

     void init() {

         lst.clear(); eidx = ;

     }

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

         edge[eidx] = Edge(from,to,cap,);

         lst.ins(from,eidx++);

         edge[eidx] = Edge(to,from,,);

         lst.ins(to,eidx++);

     }

     queue<int> bfsq; bool vis[MAXV];

     int dist[MAXV];

     bool bfs() {

         memset( vis, false, sizeof(vis) );

         bfsq.push(s); vis[s] = true; dist[s] = ;

         while( !bfsq.empty() ) {

             int u = bfsq.front(); bfsq.pop();

             for( int i = lst.head[u]; ~i; i = lst.nxt[i] ) {

                 Edge &e = edge[lst.val[i]]; int v = e.to;

                 if( !vis[v] && e.cap > e.flow ) {

                     vis[v] = true; dist[v] = dist[u] + ;

                     bfsq.push(v);

                 }

             }

         } return vis[t];

     }

     int cur[MAXV];

     int dfs( int u, int res ) {

         if( u == t || res ==  ) return res;

         int flow = ;

         if( cur[u] == INF ) cur[u] = lst.head[u];

         for( int &i = cur[u]; ~i; i = lst.nxt[i] ) {

             Edge &e = edge[lst.val[i]]; int v = e.to;

             if( e.cap > e.flow && dist[v] == dist[u] +  ) {

                 int nxtf = dfs( v, min( res, e.cap-e.flow ) );

                 if( nxtf ==  ) continue;

                 flow += nxtf; res -= nxtf;

                 e.flow += nxtf; edge[lst.val[i]^].flow -= nxtf;

                 if( res ==  ) break;

             }

         } return flow;

     }

     int solve( int s, int t ) {

         int flow = ;

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

         while( bfs() ) {

             memset( cur, 0x3f, sizeof(cur) );

             flow += dfs(s,INF);

         } return flow;

     }

 };

 Dinic< MAXN<<, MAXN*(MAXN+) > dinic;

 // j表示点的类别

 // 0表示人，1表示床，2表示s和t

 inline int id( int i, int j ) {

     return i+j*n;

 }

 int main() {

     int T; scanf( "%d", &T );

     while( T-- ) {

         scanf( "%d", &n ); dinic.init();

         int need = n; // 需要住宿的人数

         int s = id(,), t = id(,);

         for( int i = ; i <= n; ++i ) {

             scanf( "%d", sch+i );

             if( sch[i] ) dinic.adde( id(i,), t,  ); // 每个在校生都有床

         }

         for( int i = ; i <= n; ++i ) {

             scanf( "%d", home+i );

             if( !sch[i] ) home[i] = -; // 非在校生不存在回不回家

             if( home[i] ==  ) need--; // 不需要住宿

             else dinic.adde( s, id(i,),  ); // 需要住宿

         }

         for( int i = ; i <= n; ++i ) for( int j = ; j <= n; ++j ) {

             int rela; scanf( "%d", &rela );

             if( home[i] ==  ) continue; // 回家的人不需要住宿

             if( sch[i] && i == j ) dinic.adde( id(i,), id(j,),  ); // 在校生可以睡自己的床

             else if( sch[j] && rela ) dinic.adde( id(i,), id(j,),  ); // 可以睡别人的床

         }

         int flow = dinic.solve(s,t);

         if( flow == need ) printf( "^_^\n" );

         else printf( "T_T\n" );

     }

     return ;

 }