#include <bits/stdc++.h>
using namespace std;

const int INF1 = 1e4;
const int INF2 = 1e8;
const int N = 405;
const int M = N*N*10;

namespace netflow {
    struct edge {
        int to, flow, next;
    } e[M*2];
    int head[N*N], ecnt = 1;
    int dis[N*N], cur[N*N];
    int S, T;
    int dinic();
    bool bfs(int S, int T);
    int dfs(int x, int flow);
    void add_edge(int a, int b, int f);
    void clear();
} using namespace netflow;

int n, m;
int a[N], b[N];
bool ta[N], tb[N];
char s[N][N];

void solve();
string rvs(string a);

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int T; cin >> T;
    while(T --> 0) solve();
}

inline int line(int x, int t) { return n*t + x; }
inline int col(int x, int t) { return n*2 + m*t + x; }

void solve()
{
    netflow::clear();
    memset(ta, 0, sizeof(ta));
    memset(tb, 0, sizeof(tb));
    
    int ans = 0;
    cin >> n >> m;
    for(int i = 1; i <= n; i++)
        cin >> a[i];
    for(int i = 1; i <= m; i++)
        cin >> b[i];
    for(int i = 1; i <= n; i++)
        cin >> (s[i]+1);
    
    map<string, int> mp;
    int cnt = n*2+m*2;
    for(int i = 1; i <= n; i++)
    {
        string tmp;
        for(int j = 1; j <= m; j++)
        {
            if(s[i][j] != '_')
                tmp += s[i][j];
            if((s[i][j] == '_' or j == m) and !tmp.empty())
            {
                string x = tmp, y = rvs(tmp);
                tmp.clear();
                if(x == y)
                {
                    if(!mp.count(x))
                        mp[x] = -1, ans++;
                    continue;
                }
                if(x > y) swap(x, y), ta[i] = true;
                if(!mp.count(x)) mp[x] = ++cnt;
                if(!mp.count(y)) mp[y] = ++cnt;
                add_edge(line(i,0), mp[x], INF2);
                add_edge(mp[y], line(i,1), INF2);
            }
        }
    }
    
    for(int j = 1; j <= m; j++)
    {
        string tmp;
        for(int i = 1; i <= n; i++)
        {
            if(s[i][j] != '_')
                tmp += s[i][j];
            if((s[i][j] == '_' or i == n) and !tmp.empty())
            {
                string x = tmp, y = rvs(tmp);
                tmp.clear();
                if(x == y)
                {
                    if(!mp.count(x))
                        mp[x] = -1, ans++;
                    continue;
                }
                if(x > y) swap(x, y), tb[j] = true;
                if(!mp.count(x)) mp[x] = ++cnt;
                if(!mp.count(y)) mp[y] = ++cnt;
                add_edge(col(j,0), mp[x], INF2);
                add_edge(mp[y], col(j,1), INF2);
            }
        }
    }
    
    for(const auto &i : mp)
    {
        string x = i.first, y = rvs(i.first);
        if(x < y) add_edge(mp[x], mp[y], 1);
    }
    
    S = cnt+1, T = cnt+2;
    
    for(int i = 1; i <= n; i++)
    {
        if(a[i] != 1)
        {
            if(ta[i] == 0) add_edge(S, line(i,0), INF1);
            else add_edge(line(i,1), T, INF1);
        }
        if(a[i] != -1)
        {
            if(ta[i] == 0) add_edge(line(i,1), T, INF1);
            else add_edge(S, line(i,0), INF1);
        }
        add_edge(line(i,0), line(i,1), INF2);
    }
    
    
    for(int j = 1; j <= m; j++)
    {
        if(b[j] != 1)
        {
            if(tb[j] == 0) add_edge(S, col(j,0), INF1);
            else add_edge(col(j,1), T, INF1);
        }
        if(b[j] != -1)
        {
            if(tb[j] == 0) add_edge(col(j,1), T, INF1);
            else add_edge(S, col(j,0), INF1);
        }
        add_edge(col(j,0), col(j,1), INF2);
    }
    
    cout << (ans+dinic()*2)%INF1 << "\n";
}

string rvs(string a)
{
    reverse(a.begin(), a.end());
    return a;
}

namespace netflow {
    int dinic()
    {
        int maxflow = 0;
        while(bfs(S, T))
            maxflow += dfs(S, INF2);
        return maxflow;
    }
    bool bfs(int S, int T)
    {
        memcpy(cur, head, sizeof(cur));
        memset(dis, 0, sizeof(dis));
        queue<int> q; int x;
        q.push(S); dis[S] = 1;
        while(!q.empty())
        {
            x = q.front(), q.pop();
            for(int i = head[x]; i; i = e[i].next)
            {
                if(e[i].flow and !dis[e[i].to])
                {
                    dis[e[i].to] = dis[x]+1;
                    q.push(e[i].to);
                }
            }
        }
        return dis[T];
    }
    int dfs(int x, int flow)
    {
        if(x == T) return flow;
        int rest = flow, i;
        for(i = cur[x]; i; i = e[i].next)
        {
            if(e[i].flow and dis[e[i].to] == dis[x]+1)
            {
                int k = dfs(e[i].to, min(rest, e[i].flow));
                if(!k) dis[e[i].to] = -1;
                e[i].flow -= k;
                e[i^1].flow += k;
                if(!(rest -= k)) break;
            }
        }
        return cur[x] = i, flow-rest;
    }
    void add_edge(int a, int b, int f)
    {
        e[++ecnt] = {b, f, head[a]}; head[a] = ecnt;
        e[++ecnt] = {a, 0, head[b]}; head[b] = ecnt;
    }
    void clear()
    {
        memset(head, 0, sizeof(head));
        ecnt = 1;
    }
}


/*
3
2 10
0 0
0 0 0 0 0 0 0 0 0 0
ADA_JARVIS
ADA_SIVRAJ
2 10
0 0
0 0 0 0 0 0 0 0 0 0
ADA_JARVIS
ADA_SIVRAJ
2 10
0 0
0 0 0 0 0 0 0 0 0 0
ADA_JARVIS
ADA_SIVRAJ

*/