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

int N , L , Q , qpt ;
struct Graph{
    struct Path{
        int pre , to ;
    } p[20005] ;
    int head[2005] , tp , N ;
    int sta[2005] , topp ;
    int dfn[2005] , dfs_c , scc[2005] , scc_cnt , inWhichId[2005] , indeg[2005] ;

    void init( int n_ ){
        for( int i = 0 ; i <= n_ ; i ++ ){
            indeg[i] = head[i] = dfn[i] = scc[i] = 0 ;
            inWhichId[i] = i ;
        }
        dfs_c = tp = topp = scc_cnt = 0 ;
        N = n_ ;
    }
    void In( int t1 , int t2 ) {
        if( t1 == t2 ) return ;
        indeg[t2] ++ ;
        p[++tp] = (Path){ head[t1] , t2 } , head[t1] = tp ;
    }
    int dfs( int u ){
        int lowu = dfn[u] = ++ dfs_c ;
        sta[++topp] = u ;
        for( int i = head[u] ; i ; i = p[i].pre ){
            int v = p[i].to ;
            if( !dfn[v] ) lowu = min( lowu , dfs( v ) ) ;
            else if( !scc[v] ) lowu = min( lowu , dfn[v] ) ;
        }
        if( lowu == dfn[u] ) {
            scc_cnt ++ ;
            while( sta[topp] != u ){
                scc[ sta[topp] ] = scc_cnt ;
                topp -- ;
            } scc[ sta[topp] ] = scc_cnt , topp -- ;
        }
        return lowu ;
    }
    void SCC(){
        for( int i = 1 ; i <= N ; i ++ ){
            if( !dfn[i] ) dfs( i ) ;
        }
        // printf( "SCC( cnt = %d ):" , scc_cnt ) ;
        // for( int i = 1 ; i <= N ; i ++ ) printf( "%d %d | " , scc[i] , dfn[i] ) ;
        // puts( ""  ) ;
    }
    void buildnew( Graph &newG ){
        newG.init( scc_cnt ) ;
        for( int u = 1 ; u <= N ; u ++ ){
            for( int i = head[u] ; i ; i = p[i].pre ){
                int v = p[i].to ;
                if( scc[u] == scc[v] ) continue ;
                newG.In( scc[u] , scc[v] ) ;
            }
        }
        // printf( "BuildNew: " ) ;
        for( int i = 1 ; i <= ::N ; i ++ ){
            newG.inWhichId[i] = scc[ this->inWhichId[i] ] ;
            // printf( "%d " , newG.inWhichId[i] ) ;
        }
        // puts( "" ) ;
    }
    void build_reverse( Graph &newG ){
        newG.init( scc_cnt ) ;
        for( int u = 1 ; u <= N ; u ++ ){
            for( int i = head[u] ; i ; i = p[i].pre ){
                int v = p[i].to ;
                if( scc[u] == scc[v] ) continue ;
                newG.In( scc[v] , scc[u] ) ;
            }
        }
        for( int i = 1 ; i <= ::N ; i ++ ){
            newG.inWhichId[i] = scc[ this->inWhichId[i] ] ;
        }
    }
} G[2005] , revG ;

struct Button{
    int p[2005] , invalid ;
    struct Edge{
        int fr , to ;
    } ;
    vector< Edge > edges ;
    void init( char *ss , int N ){
        invalid = 0 ;
        int c[2005] , whereinvalid = 0 ;
        for( int i = 1 ; i <= N ; i ++ ) c[i] = 0 ;
        for( int i = 1 ; i <= N ; i ++ ){
            int c1 = (int)ss[i*2-1] , c2 = (int)ss[i*2] ;
            p[i] = ( c1 - 48 ) * 50 + c2 - 48 ;
            if( !c[ p[i] ] ){
                c[ p[i] ] = i ;
            } else {
                if( !whereinvalid ){
                    whereinvalid = i ; // position
                } else {
                    invalid = 1 ;
                }
            }
        }
        edges.clear() ;
        // printf( "Button:" ) ;
        // for( int i = 1 ; i <= N ; i ++ ) printf( "%d " , p[i] ) ;
        // puts("" ) ;
        if( invalid ) return ;
        else if( whereinvalid ){
            int emptynum = 0 ;
            for( int i = 1 ; i <= N ; i ++ )
                if( !c[i] ) { emptynum = i ; break ; }
            edges.push_back( (Edge){ whereinvalid , emptynum } ) ;
            edges.push_back( (Edge){ c[p[whereinvalid]] , emptynum } ) ;
        } else {
            for( int i = 1 ; i <= N ; i ++ ){
                edges.push_back( (Edge){ i , p[i] } ) ;
            }
        }
    }
} b[2005] ;

struct Query {
    int A , B , C , pos , ans ;
    bool operator < ( const Query &AA ) const {
        return C < AA.C ;
    }
    int decode( int x , int y ){
        return ( x - 48 ) * 50 + y - 48 ;
    }
    void init( char *ss ){
        A = decode( ss[1] , ss[2] ) ;
        B = decode( ss[3] , ss[4] ) ;
        C = decode( ss[5] , ss[6] ) ;        
        // printf( "Query: %d %d %d"  , A , B , C ) ;
        // puts("" ) ;
    }
} q[1000005]  ;
int ans[1000005] ;

void solve(){
    qpt = 1 ;
    sort( q + 1 , q + Q + 1 ) ;
    G[0].init( N ) ;
    for( int i = 0 ; i <= L ; i ++ ){
        for( auto e : b[i].edges ){
            // printf( "origin(%d to %d), inGraph(%d to %d)\n" , e.fr , e.to , G[i].inWhichId[e.fr] , G[i].inWhichId[e.to] ) ;
            G[i].In( G[i].inWhichId[e.fr] , G[i].inWhichId[e.to] ) ;
        }
        G[i].SCC() ;
        G[i].buildnew( G[i+1] ) ;
        G[i].build_reverse( revG ) ;

        bitset<2005> f[2005] ;
        queue<int> que ;
        for( int i = 1 ; i <= revG.N ; i ++ ){
            if( revG.indeg[i] == 0 ) que.push( i ) ;
            f[i].reset() ;
            f[i][i] = 1 ;
        }
        while( que.empty() == false ){
            int u = que.front() ;
            que.pop() ;
            for( int i = revG.head[u] ; i ; i = revG.p[i].pre ){
                int v = revG.p[i].to ;
                revG.indeg[v] -- ;
                if( revG.indeg[v] == 0 ){
                    que.push( v ) ;
                }
                f[v] |= f[u] ;
            }
        }

        while( qpt <= Q && q[qpt].C <= i ){
            int u = q[qpt].A , v = q[qpt].B ;
            u = revG.inWhichId[u] , v = revG.inWhichId[v] ;
            // printf( "u = %d, v = %d , [u][v] = %d\n" , u , v , f[u][v] ) ;
            q[qpt].ans = f[u][v] ;
            qpt ++ ;
        }
    }
}

int main(){
    int T ;
    scanf( "%d" , &T ) ;
    while( T -- ){
        char ss[20005] ; 
        scanf( "%d%d%d" , &N , &L , &Q ) ;
        for( int i = 1 ; i <= L ; i ++ ){
            scanf( "%s" , ss + 1 ) ;
            b[i].init( ss , N ) ;
        }
        for( int i = 1 ; i <= Q ; i ++ ){
            scanf( "%s" , ss + 1 ) ;
            q[i].init( ss ) ;
            q[i].pos = i ;
        }
        solve() ;
        for( int i = 1 ; i <= Q ; i ++ ) ans[ q[i].pos ] = q[i].ans ;
        for( int i = 1 ; i <= Q ; i ++ ) printf( "%d" , ans[i] ) ;
        puts( "" ) ;
    }
}