#include<iostream>
#include<vector>
#include<algorithm>
#include<bitset>
#include<map>
#include<set>
#include<unordered_set>

using namespace std;

typedef bitset<400> Board;

int bh,bw;
Board bb;
Board mask;
unordered_set<Board> cand;

struct P{
  int h,w;
  vector<vector<char> > g;
  P(){
    cin>>h>>w;
    g=vector<vector<char> >(h,vector<char>(w));
    for(int i=0;i<h;i++){
      for(int j=0;j<w;j++){
	char c;
	cin>>c;
	g[i][j]=c=='#';
      }
    }
  }
  void rot(){
    vector<vector<char> > n(w,vector<char>(h));
    for(int i=0;i<h;i++){
      for(int j=0;j<w;j++){
	n[j][h-1-i]=g[i][j];
      }
    }
    g=n;
    swap(h,w);
  }
  Board to_board()const{
    Board b;
    for(int i=0;i<h;i++){
      for(int j=0;j<w;j++){
	b[i*20+j]=g[i][j];
      }
    }
    return b;
  }
  vector<Board> to_boards(){
    vector<Board> v;
    for(int i=0;i<4;i++){
      rot();
      for(int j=-19;j<20;j++){
	for(int k=-19;k<20;k++){
	  Board b;
	  for(int l=0;l<h;l++){
	    for(int m=0;m<w;m++){
	      if(g[l][m]){
		int y=l+j;
		int x=k+m;
		if(y<0||bh<=y||x<0||bw<=x||bb[y*20+x])goto next;
		b[y*20+x]=true;
	      }
	    }
	  }
	  v.push_back(b);
	next:
	  ;
	}
      }
    }
    return v;
  } 
};

vector<vector<Board> > pieces;

Board mem;

void ff(int y,int x){
  if(y<0||bh<=y||x<0||bw<=x||mem[y*20+x])return;
  mem[y*20+x]=true;
  for(int i=0;i<4;i++){
    static int d[]={0,-1,0,1,0};
    ff(y+d[i],x+d[i+1]);
  }
}

int nc(const Board &b){
  mem=b;
  int c=0;
  for(int i=0;i<bh;i++){
    for(int j=0;j<bw;j++){
      if(!mem[i*20+j]){
	c++;
	ff(i,j);
      }
    }
  }
  return c;
}

bool rec(const Board &b,vector<int> r);
bool rec2(const Board &b,vector<int> r);

bool rec(const Board &b,vector<int> r){
  //  if(nc(b)>r.size())return false;
  if(r.empty())return true;
  int x=r.back();
  r.pop_back();
  for(auto &e:pieces[x]){
    if((b&e).none()){
      if(rec(b|e,r))return true;
    }
  }
  return false;
}

bool rec2(const Board &b,vector<int> r){
  //  if(nc(b)>r.size())return false;
  if(r.empty())return true;
  for(int i=0;i<bh;i++){
    for(int j=0;j<bw;j++){
      if(!b[i*20+j]){
	for(int k=0;k<r.size();k++){
	  for(auto &p:pieces[r[k]]){
	    if(p[i*20+j]&&(b&p).none()){
	      vector<int> nr=r;
	      nr.erase(begin(nr)+k);
	      if(rec2(b|p,nr))return true;
	    }
	  }
	}
	return false;
      }
    }
  }
}

void hzf(const Board &b,vector<int> r){
  if(r.empty()&&(nc(b|bb)<=5||true)){
    cand.insert(b);
  }else{
    int x=r.back();
    r.pop_back();
    for(auto &e:pieces[x]){
      if((b&e).none()){
	hzf(b|e,r);
      }
    }
  }
}

bool hzl(const Board &b,vector<int> r){
  if(r.empty()){
    return cand.count(~(bb|b)&mask);
  }else{
    int x=r.back();
    r.pop_back();
    for(auto &e:pieces[x]){
      if((b&e).none()){
	if(hzl(b|e,r))return true;
      }
    }
    return false;
  }
}


int main(){
  for(;;){
    P b;
    bh=b.h;
    bw=b.w;
    bb=b.to_board();
    mask.reset();
    for(int i=0;i<bh;i++){
      for(int j=0;j<bw;j++){
	mask[i*20+j]=true;
      }
    }
    if(b.h==0)break;
    int n;
    cin>>n;
    pieces.clear();
    pieces.resize(n);
    vector<int> vnb(n);
    for(int i=0;i<n;i++){
      P cp;
      pieces[i]=cp.to_boards();
      vnb[i]=cp.to_board().count();
    }
    int p;
    cin>>p;
    map<set<int>,bool> m;
    while(p--){
      int k;
      cin>>k;
      int sp=0;
      vector<int> cp;
      int nb=bb.count();
      for(int i=0;i<k;i++){
	int t;
	cin>>t;
	sp|=1<<t-1;
	cp.push_back(t-1);
	nb+=vnb[t-1];
      }
      set<int> s(begin(cp),end(cp));
      sort(begin(cp),end(cp),[&](int a,int b){
      	  return pieces[a].size()<pieces[b].size();
      	});
      if(!m.count(s)){
	if(nb!=bh*bw){
	  m[s]=false;
	}else{
	  auto md=begin(cp)+(k+1)/2;
	  vector<int> f(begin(cp),md);
	  vector<int> l(md,end(cp));
	  cand.clear();
	  hzf(Board(),f);
	  m[s]=hzl(Board(),l);
	}
      }
      cout<<(m[s]?"YES":"NO")<<endl;
    }
  }
}