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

namespace OCTANE
{
    template <typename T> inline bool read(T &x)
    {
        x = 0; bool f = 0; char ch = getchar();
        if (ch == EOF) return false;
        while (ch < '0' || ch > '9')
        {
            if (ch == '-') f = 1; ch = getchar();
        }
        while (ch >= '0' && ch <= '9')
        {
            x = (x << 1) + (x << 3) + (ch^48); ch = getchar();
        }
        if (f) x = -x; return true;
    }
    template <typename T> inline void print(T x)
    {
        if (x < 0) putchar('-'), x = -x;
        if (x > 9) print(x / 10);
        putchar(x%10 + '0');
    }
    template <typename T, typename ...TT>
    inline void print(T x, char c)
    {
        print(x); putchar(c);
    }
    template <typename T, typename ...TT>
    inline int read(T &x, TT &...y)
    {
        return read(x) + read(y...);
    }

}using namespace OCTANE;

#define ull unsigned long long
const int SIZE=80;
const int MAXN=3005;
const int N=1e6+5;
const ull Base=233;
const int INF=0x3f3f3f3f;

struct EDGE{
    
    int nxt,v;
    int w;
    
}edge[N];
int head[MAXN],cur[MAXN],cnt=1;

void add_edge(int u,int v,int w){

    edge[++cnt].v=v;
    edge[cnt].w=w;
    edge[cnt].nxt=head[u];
    head[u]=cnt;
    
    edge[++cnt].v=u;
    edge[cnt].w=0;
    edge[cnt].nxt=head[v];
    head[v]=cnt;
    
}

int dis[MAXN];
bool bfs(int s,int t){

    memset(dis,0,sizeof(dis));
    memcpy(cur,head,sizeof(cur));
    
    queue<int> q;
    q.push(s);
    dis[s]=1;
    
    while(!q.empty())
    {
        int u=q.front();
        q.pop();
        for(int i=head[u];i;i=edge[i].nxt)
        {
            int v=edge[i].v;
            if(!dis[v]&&edge[i].w)
            {
                dis[v]=dis[u]+1;
                q.push(v);
            }
        }
    }
    return dis[t];
    
}

int dfs(int u,int flow,int t){

    if(u==t||!flow) return flow;
    
    int rest=flow,i;
    for(i=cur[u];i;i=edge[i].nxt)
    {
        int v=edge[i].v;
        if(dis[v]==dis[u]+1&&edge[i].w)
        {
            int k=dfs(v,min(rest,edge[i].w),t);
            if(!k)
            {
                dis[v]=0;
                continue;
            }
            edge[i].w-=k,edge[i^1].w+=k;
            rest-=k;
            if(!rest) break;
        }
    } 
    
    cur[u]=i;
    
    return flow-rest;
    
}

int dinic(int s,int t){

    int flow=0;
    while(bfs(s,t))
        flow+=dfs(s,INF,t);
    return flow;
    
}

ull pw[SIZE],H[SIZE],RH[SIZE];
map<ull,int> mp1,mp2;

char s[SIZE][SIZE];
int a[SIZE],b[SIZE];
int rtot[SIZE],ctot[SIZE];
int row[2][SIZE][SIZE],col[2][SIZE][SIZE],big[MAXN];

void clear(){

    cnt=1;
    memset(big,0,sizeof(big));
    memset(head,0,sizeof(head));
    memset(rtot,0,sizeof(rtot));
    memset(ctot,0,sizeof(ctot));
    mp1.clear(),mp2.clear();
    
}

void solve(){
    
    clear();
    
    int n,m;
    read(n,m);
    for(int i=1;i<=n;i++)
        read(a[i]);
    for(int i=1;i<=m;i++)
        read(b[i]);
    
    int ans=0,id_tot=0;
    for(int i=1;i<=n;i++)
    {
        scanf("%s",s[i]+1);
        for(int j=1;j<=m;j++)
            H[j]=H[j-1]*Base+s[i][j];
        for(int j=m;j>=1;j--)
            RH[j]=RH[j+1]*Base+s[i][j];
        
        int lst=1;
        for(int j=1;j<=m;j++)
        {
            if(s[i][j]=='_'||j==m)
            {
                int l=lst,r=j-1;
                lst=j+1;
                if(s[i][j]!='_') r++;
                if(l>r) continue;
                
                ull hsh=H[r]-H[l-1]*pw[r-l+1];
                ull rhsh=RH[l]-RH[r+1]*pw[r-l+1];
                
                if(hsh==rhsh)
                {
                    if(mp2[hsh]) continue;
                    ans++,mp2[hsh]=1;
                    continue;
                }
                if(!mp1[hsh])
                {
                    int turn=1;
                    for(int k=1;k<=r-l+1;k++)
                    {
                        if(s[i][l+k-1]>s[i][r-k+1]) break;
                        else if(s[i][l+k-1]<s[i][r-k+1])
                        {
                            turn=-1;
                            break;
                        }
                    }
                    mp1[hsh]=++id_tot,big[id_tot]=turn;
                    mp1[rhsh]=++id_tot,big[id_tot]=-turn;
                }
                rtot[i]++;
                row[0][i][rtot[i]]=mp1[hsh];
                row[1][i][rtot[i]]=mp1[rhsh];
            }
        }
    }
    for(int j=1;j<=m;j++)
    {
        for(int i=1;i<=n;i++)
            H[i]=H[i-1]*Base+s[i][j];
        for(int i=n;i>=1;i--)
            RH[i]=RH[i+1]*Base+s[i][j];
        
        int lst=1;
        for(int i=1;i<=n;i++)
        {
            if(s[i][j]=='_'||i==n)
            {
                int l=lst,r=i-1;
                lst=i+1;
                if(s[i][j]!='_') r++;
                if(l>r) continue;
                
                ull hsh=H[r]-H[l-1]*pw[r-l+1];
                ull rhsh=RH[l]-RH[r+1]*pw[r-l+1];
                
                if(hsh==rhsh)
                {
                    if(mp2[hsh]) continue;
                    ans++,mp2[hsh]=1;
                    continue;
                }
                
                if(!mp1[hsh])
                {
                    int turn=1;
                    for(int k=1;k<=r-l+1;k++)
                    {
                        if(s[l+k-1][j]>s[r-k+1][j]) break;
                        else if(s[l+k-1][j]<s[r-k+1][j])
                        {
                            turn=-1;
                            break;
                        }
                    }
                    mp1[hsh]=++id_tot,big[id_tot]=turn;
                    mp1[rhsh]=++id_tot,big[id_tot]=-turn;
                }
                ctot[j]++;
                col[0][j][ctot[j]]=mp1[hsh];
                col[1][j][ctot[j]]=mp1[rhsh];
            }
        }
    }
    
    int S=id_tot+n+m+1,T=S+1;
    for(int i=1;i<=id_tot;i+=2)
    {
        int x=i,y=i+1;
        if(big[x]==1) swap(x,y);
        add_edge(x,y,2);
    }
    
    for(int i=1;i<=n;i++)
    {
        if(!rtot[i]) continue;
        if((a[i]==1&&big[row[0][i][1]]<0)||(a[i]==-1&&big[row[1][i][1]]<0))
        {
            add_edge(S,id_tot+i,INF);
            for(int j=1;j<=rtot[i];j++)
            {
                if(a[i]==1) add_edge(id_tot+i,row[0][i][j],INF);
                else add_edge(id_tot+i,row[1][i][j],INF);
            }
        }
        else if((a[i]==1&&big[row[0][i][1]]>0)||(a[i]==-1&&big[row[1][i][1]]>0))
        {
            add_edge(id_tot+i,T,INF);
            for(int j=1;j<=rtot[i];j++)
            {
                if(a[i]==1) add_edge(row[0][i][j],id_tot+i,INF);
                else add_edge(row[1][i][j],id_tot+i,INF);
            }
        }
        else
        {
            for(int j=1;j<=rtot[i];j++)
            {
                int x=row[0][i][j],y=row[1][i][j];
                if(big[x]>0) swap(x,y);
                add_edge(id_tot+i,x,INF);
                add_edge(y,id_tot+i,INF);
            }
        }
    }
    for(int i=1;i<=m;i++)
    {
        if(!ctot[i]) continue;
        if((b[i]==1&&big[col[0][i][1]]<=0)||(b[i]==-1&&big[col[1][i][1]]<=0))
        {
            add_edge(S,id_tot+n+i,INF);
            for(int j=1;j<=ctot[i];j++)
            {
                if(b[i]==1) add_edge(id_tot+n+i,col[0][i][j],INF);
                else add_edge(id_tot+n+i,col[1][i][j],INF);
            }
        }
        else if((b[i]==1&&big[col[0][i][1]]>=0)||(b[i]==-1&&big[col[1][i][1]]>=0))
        {
            add_edge(id_tot+n+i,T,INF);
            for(int j=1;j<=ctot[i];j++)
            {
                if(b[i]==1) add_edge(col[0][i][j],id_tot+n+i,INF);
                else add_edge(col[1][i][j],id_tot+n+i,INF);
            }
        }
        else
        {
            for(int j=1;j<=ctot[i];j++)
            {
                int x=col[0][i][j],y=col[1][i][j];
                if(big[x]>0) swap(x,y);
                add_edge(id_tot+n+i,x,INF);
                add_edge(y,id_tot+n+i,INF);
            }
        }
    }

    print(ans+dinic(S,T),'\n');
    
}

int main(){

    // freopen("a.in","r",stdin);
    // freopen("a.out","w",stdout);

    int T;
    read(T);
    
    pw[0]=1;
    for(int i=1;i<=75;i++)
        pw[i]=pw[i-1]*Base;
    
    while(T--)
        solve();
    
    return 0;
}