#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) {
    return (ull)rng() % B;
}

struct UnionFind{
    vector<int> par,num;
    UnionFind(int n):par(n),num(n,1){
        iota(par.begin(),par.end(),0);  //include<numeric>
    }
    int find(int v){
        return (par[v]==v)?v:(par[v]=find(par[v]));
    }
    void unite(int u,int v){
        u=find(u),v=find(v);
        if(u==v)return;
        if(num[u]<num[v])swap(u,v);
        num[u]+=num[v];
        par[v]=u;
    }
    bool same(int u,int v){
        return find(u) == find(v);
    }
    int size(int v){
        return num[find(v)];
    }
};

template<typename T>
struct dinic{
    struct edge{
        int to;
        T c,f;
    };
    T eps;
    const T inf=numeric_limits<T>::max();
    int n,m = 0;
    vector<edge> e;
    vector<vector<int>> g;
    vector<int> level, ptr;
    dinic(int n): n(n), g(n), level(n), ptr(n) {
        eps = (T)1 / (T)1e9;
    }
    void add_edge(int s, int t, T c){
        e.push_back({t, c, 0});
        e.push_back({s, 0, 0});
        g[s].push_back(m++);
        g[t].push_back(m++);
    }
    bool bfs(int s, int t){
        fill(level.begin(), level.end(), -1);
        level[s] = 0;
        for(queue<int> q({s});q.size();q.pop()){
            int s = q.front();
            for(int i:g[s]){
                int t = e[i].to;
                if(level[t] == -1 and (e[i].c - e[i].f) > eps){
                    level[t] = level[s] + 1;
                    q.push(t);
                }
            }
        }
        return (level[t] != -1);
    }
    T dfs(int s, int t, T psh){
        if(!(psh > eps) or s == t) return psh;
        for(int &i = ptr[s]; i < (int)g[s].size(); ++i){
            auto &eg = e[g[s][i]];
            if(level[eg.to] != level[s] + 1 or !(eg.c - eg.f > eps)) continue;
            T f = dfs(eg.to, t, min(psh, eg.c-eg.f));
            if(f > eps){
                eg.f += f;
                e[g[s][i]^1].f -= f;
                return f;
            }
        }
        return 0;
    }
    T max_flow(int s, int t){
        T f = 0;
        while(bfs(s,t)){
            fill(ptr.begin(), ptr.end(), 0);
            while(1){
                T c = dfs(s, t, inf);
                if(c > eps){
                    f += c;
                }
                else{
                    break;
                }
            }
        }
        return f;
    }
    // ABC239-G
    vector<bool> min_cut(int s){
        vector<bool> visited(n);
        queue<int> q; q.push(s);
        while(q.size()){
            int p = q.front(); q.pop();
            visited[p] = true;
            for(auto idx:g[p]){
                auto eg = e[idx];
                if(eg.c - eg.f > eps and !visited[eg.to]){
                    visited[eg.to] = true;
                    q.push(eg.to);
                }
            }
        }
        return visited;
    }
};

int main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int q; cin >> q;
    while (q--) {
        // input
        int n,m; cin >> n >> m;
        const int N = 2*n*m;
        int H,V; cin >> H >> V;
        vector<string> dir(n);
        for (int i = 0; i < n; ++i) {
            cin >> dir[i];
        }
        vector<bool> black(N+1);
        {
            int idx = 0;
            for (int i = 0; i < n; ++i) {
                string s; cin >> s;
                for (int j = 0; j < 2*m; ++j) {
                    black[idx++] = (s[j] == '#');
                }
            }
        }
        vector<vector<int>> D(n,vector<int>(m));
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                cin >> D[i][j];
            }
        }

        auto gid = [&](int x, int y, int z) -> int {
            if (0 <= x and x < n and 0 <= y and y < m) {
                return (x*m + y) * 2 + z;
            }
            else return N; // 外側
        };

        const int inf = (1<<30);
        vector<tuple<int,int,int>> edge;
        auto add = [&](int i, int j, int c) -> void {
            if (black[i] or black[j]) c = inf;
            edge.push_back({i, j, c});
        };

        // yoko
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j <= m; ++j) {
                int x = gid(i, j-1, 1);
                int y = gid(i, j, 0);
                add(x, y, V);
            }
        }
        // tate
        for (int i = 0; i <= n; ++i) {
            for (int j = 0; j < m; ++j) {
                // z: 0 -> sita, 1 -> ue
                auto f = [&](int x, int y, int z) -> int {
                    if (0 <= x and x < n) {
                        if(dir[x][y] == '/') return gid(x, y, 1-z);
                        else return gid(x, y, z);
                    }
                    else {
                        return N;
                    }
                };
                add(f(i-1,j,0), f(i,j,1), H);
            }
        }
        // naname
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                int x = gid(i, j, 0);
                int y = gid(i, j, 1);
                add(x, y, D[i][j]);
            }
        }

        UnionFind uf(N);
        // 黒い三角形からなる連結成分を求める
        // 全ての格子点について調べれば良い
        for (int i = 0; i <= n; ++i) {
            for (int j = 0; j <= m; ++j) {
                int vs = -1;
                auto f = [&](int x, int y, int z) -> void {
                    int id = gid(x,y,z);
                    if (black[id]) {
                        if (vs == -1) vs = id;
                        else uf.unite(vs, id);
                    }
                };

                // 左上
                if (i and j) {
                    if (dir[i-1][j-1] == '/') {
                        f(i-1, j-1, 1);
                    }
                    else {
                        f(i-1, j-1, 0);
                        f(i-1, j-1, 1);
                    }
                }
                // 右上
                if (i and j < m) {
                    if (dir[i-1][j] == '/') {
                        f(i-1, j, 0);
                        f(i-1, j, 1);
                    }
                    else {
                        f(i-1, j, 0);
                    }
                }
                // 左下
                if (i < n and j) {
                    if (dir[i][j-1] == '/') {
                        f(i, j-1, 0);
                        f(i, j-1, 1);
                    }
                    else {
                        f(i, j-1, 1);
                    }
                }
                // 右下
                if (i < n and j < m) {
                    if (dir[i][j] == '/') {
                        f(i, j, 0);
                    }
                    else {
                        f(i, j, 0);
                        f(i, j, 1);
                    }
                }
            }
        }

        vector<vector<int>> stickers(N);
        for (int i = 0; i < N; ++i) {
            if (black[i]) {
                stickers[uf.find(i)].push_back(i);
            }
        }
        {
            auto cp = stickers; stickers.clear();
            for (int i = 0; i < N; ++i) {
                if (cp[i].size()) {
                    stickers.push_back(cp[i]);
                }
            }
        }
        int sz = stickers.size();
        int lg = 0;
        while ((1<<lg) < sz) lg++;

        int L = edge.size();
        vector<bool> cut(L);
        for (int i = 0; i < L; ++i) {
            auto [x,y,z] = edge[i];
            if (max(x,y) == N) cut[i] = true;
        }

        // 全ての連結成分を切り分ける
        // https://twitter.com/m_99kyopro/status/1507717061325193224
        for (int bit = 0; bit < lg; ++bit) {
            dinic<int> g(N+2);
            int S = N, T = N+1;
            for (int i = 0; i < L; ++i) {
                if (cut[i]) continue;
                auto [x,y,z] = edge[i];
                g.add_edge(x, y, z);
                g.add_edge(y, x, z);
            }
            for (int i = 0; i < sz; ++i) {
                for (int j : stickers[i]) {
                    if ((1<<bit) & i) g.add_edge(S, j, inf);
                    else g.add_edge(j, T, inf);
                }
            }
            g.max_flow(S, T);
            auto visited = g.min_cut(S);
            for (int i = 0; i < L; ++i) {
                if (cut[i]) continue;
                auto [x,y,z] = edge[i];
                if(visited[x] != visited[y]) cut[i] = true;
            }
        }

        // 連結成分が1個の状態に帰着
        // 切り分けたので、まとめて1回のフローで処理できる
        {
            dinic<int> g(N+2);
            int S = N, T = N+1;
            for (int i = 0; i < L; ++i) {
                auto [x,y,z] = edge[i];
                if (cut[i]) {
                    if (x != N) g.add_edge(x, T, z);
                    if (y != N) g.add_edge(y, T, z);
                }
                else {
                    g.add_edge(x, y, z);
                    g.add_edge(y, x, z);
                }
            }
            for (int i = 0; i < sz; ++i) {
                for (int j : stickers[i]) {
                    g.add_edge(S, j, inf);
                }
            }
            g.max_flow(S, T);
            auto visited = g.min_cut(S);
            for (int i = 0; i < L; ++i) {
                if (cut[i]) continue;
                auto [x,y,z] = edge[i];
                if(visited[x] != visited[y]) cut[i] = true;
            }
        }

        // コスト計算
        vector<int> res(sz);
        {
            vector<vector<int>> g(N);
            vector<int> cost(N);
            for (int i = 0; i < L; ++i) {
                auto [x,y,z] = edge[i];
                if (cut[i]) {
                    if (x != N) cost[x] += z;
                    if (y != N) cost[y] += z;
                }
                else {
                    g[x].push_back(y);
                    g[y].push_back(x);
                }
            }

            vector<bool> used(N);
            queue<int> que;
            for (int i = 0; i < sz; ++i) {
                for (int j : stickers[i]) {
                    que.push(j); used[j] = true;
                }
                while (que.size()) {
                    int s = que.front(); que.pop();
                    res[i] += cost[s];
                    for (int t : g[s]) {
                        if (!used[t]) {
                            que.push(t); used[t] = true;
                        }
                    }
                }
            }
        }

        // output
        sort(res.begin(), res.end());
        cout << res.size() << "\n";
        for (int i = 0; i < sz; ++i) {
            if (i) cout << " ";
            cout << res[i];
        }
        cout << "\n";
    }
}