#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

typedef int JQK;

int n, m;

char ch[][];

const int dir[][] = {{, }, {, }, {, -}, { -, }};

namespace dinic {

        const int MAXN = ;

        const int MAXM = ;

        const int INF = ;

        int Head[MAXN], cur[MAXN], lev[MAXN], to[MAXM << ], nxt[MAXM << ], ed = ;

        int S, T, MAXP;

        JQK f[MAXM << ];

        inline void addedge(int u, int v, JQK cap) {

                to[++ed] = v;

                nxt[ed] = Head[u];

                Head[u] = ed;

                f[ed] = cap;

                to[++ed] = u;

                nxt[ed] = Head[v];

                Head[v] = ed;

                f[ed] = ;

                return;

        }

        inline bool BFS() {

                int u;

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

                        lev[i] = -;

                }

                //memset(lev, -1, sizeof(lev));

                queue<int>q;

                lev[S] = ;

                q.push(S);

                while (q.size()) {

                        u = q.front();

                        q.pop();

                        for (int i = Head[u]; i; i = nxt[i])

                                if (f[i] && lev[to[i]] == -) {

                                        lev[to[i]] = lev[u] + ;

                                        q.push(to[i]);

                                        /*

                                        if (to[i] == T)

                                        {

                                                return 1;

                                        }

                                        magic one way optimize

                                        */

                                }

                }

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

                        cur[i] = Head[i];

                }

                //memcpy(cur, Head, sizeof Head);

                return lev[T] != -;

        }

        JQK DFS(int u, JQK maxf) {

                if (u == T || !maxf) {

                        return maxf;

                }

                JQK cnt = , tem;

                for (int &i = cur[u]; i; i = nxt[i])

                        if (f[i] && lev[to[i]] == lev[u] + ) {

                                tem = DFS(to[i], min(maxf, f[i]));

                                maxf -= tem;

                                f[i] -= tem;

                                f[i ^ ] += tem;

                                cnt += tem;

                                if (!maxf) {

                                        break;

                                }

                        }

                if (!cnt) {

                        lev[u] = -;

                }

                return cnt;

        }

        JQK Dinic() {

                JQK ans = ;

                while (BFS()) {

                        ans += DFS(S, INF);

                }

                return ans;

        }

        void init(int SS, int TT) {

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

                        Head[i] = ;

                }

                ed = ;

                S = SS;

                T = TT;

                return;

        }

        void work(int aim) {

                int u, v, c;

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

                        for (int j = ; j <= m; j++) {

                                if (ch[i][j] == '') {

                                        continue;

                                }

                                for (int k = ; k < ; k++) {

                                        int dx = i + dir[k][];

                                        int dy = j + dir[k][];

                                        if (dx >=  && dx <= n && dy >=  && dy <= m) {

                                                if (ch[dx][dy] == '') {

                                                        continue;

                                                }

                                                addedge((i - )*m + j, (dx - )*m + dy, );

                                        }

                                }

                        }

                }

                int ans = Dinic();

                printf(ans == aim ? "Yes\n" : "No\n");

        }

}

int main() {

        int TNT, a, b, x, s, t;

        scanf("%d", &TNT);

        while (TNT--) {

                scanf("%d %d", &n, &m);

                scanf("%d %d", &a, &b);

                dinic::MAXP = n * m + ;

                s = n * m + ;

                t = s + ;

                dinic::init(s, t);

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

                        scanf("%s", ch[i] + );

                }

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

                        scanf("%d", &x);

                        dinic::addedge(s, x, );

                }

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

                        scanf("%d", &x);

                        dinic::addedge(x + (n - )*m, t, );

                }

                if (a > b) {

                        printf("No\n");

                        continue;

                }

                dinic::work(a);

        }

        return ;

}