#include <bits/stdc++.h>
using namespace std;
int parent[1000010], _rank[1000010];
void init(int n) {
  int i;
  for ((i) = 0; (i) < (int)(n); (i)++) {
    parent[i] = i;
    _rank[i] = 1;
  }
}
int root(int x) {
  if (parent[x] != x) parent[x] = root(parent[x]);
  return parent[x];
}
void connect(int x, int y) {
  int rx = root(x), ry = root(y);
  if (rx == ry) return;
  if (_rank[rx] > _rank[ry]) {
    parent[ry] = rx;
    _rank[rx] += _rank[ry];
  }
  if (_rank[rx] <= _rank[ry]) {
    parent[rx] = ry;
    _rank[ry] += _rank[rx];
  }
}
int Z;
int X, Y, Q;
char board[1010][1010];
int g[1010][1010];
int gS, gT;
set<pair<int, int> > weak_edge;
bool valid(int x, int y) {
  return (x >= 0 && x < X && y >= 0 && y < Y && board[x][y] == '#');
}
bool is_weak_edge(int p, int q) {
  if (p > q) swap(p, q);
  return (weak_edge.find(make_pair(p, q)) != weak_edge.end());
}
int px[20], py[20];
map<int, vector<int> > graph;
set<int> visited;
void add_edge(int s, int t) {
  graph[s].push_back(t);
  graph[t].push_back(s);
}
void dfs(int v) {
  if (visited.find(v) != visited.end()) return;
  visited.insert(v);
  vector<int> adj = graph[v];
  int i;
  for ((i) = 0; (i) < (int)(adj.size()); (i)++) dfs(adj[i]);
}
vector<int> get_comp(int root) {
  visited.clear();
  dfs(root);
  vector<int> v;
  for (__typeof((visited).begin()) itr = (visited).begin();
       itr != (visited).end(); itr++)
    v.push_back(*itr);
  return v;
}
bool connected_weakly(int s, int t) {
  if (s >= Z && t >= Z) {
    s -= Z;
    t -= Z;
    return (((px[s] - px[t]) > 0 ? (px[s] - px[t]) : -(px[s] - px[t])) <= 2 &&
            ((py[s] - py[t]) > 0 ? (py[s] - py[t]) : -(py[s] - py[t])) <= 2);
  }
  if (s >= Z) {
    s -= Z;
    if (t == gS)
      if (px[s] <= 1 || py[s] >= Y - 2) return true;
    if (t == gT)
      if (px[s] >= X - 2 || py[s] <= 1) return true;
    int i, j;
    for (i = -2; i <= 2; i++)
      for (j = -2; j <= 2; j++) {
        int x = px[s] + i;
        int y = py[s] + j;
        if (valid(x, y) && g[x][y] == t) return true;
      }
    return false;
  }
  if (t >= Z) return connected_weakly(t, s);
  return is_weak_edge(s, t);
}
bool query(void) {
  int K, i, j, dx, dy;
  Z = X * Y + 2;
  graph.clear();
  scanf("%d", &K);
  for ((i) = 0; (i) < (int)(K); (i)++) scanf("%d%d", &px[i], &py[i]);
  for ((i) = 0; (i) < (int)(K); (i)++) {
    px[i]--;
    py[i]--;
  }
  for ((i) = 0; (i) < (int)(K); (i)++)
    for ((j) = 0; (j) < (int)(i); (j)++)
      if (((px[i] - px[j]) > 0 ? (px[i] - px[j]) : -(px[i] - px[j])) <= 1 &&
          ((py[i] - py[j]) > 0 ? (py[i] - py[j]) : -(py[i] - py[j])) <= 1)
        add_edge(Z + i, Z + j);
  for ((i) = 0; (i) < (int)(K); (i)++) {
    int x = px[i];
    int y = py[i];
    if (x == 0 || y == Y - 1) add_edge(Z + i, gS);
    if (x == X - 1 || y == 0) add_edge(Z + i, gT);
  }
  for ((i) = 0; (i) < (int)(K); (i)++)
    for (dx = -1; dx <= 1; dx++)
      for (dy = -1; dy <= 1; dy++) {
        int x2 = px[i] + dx;
        int y2 = py[i] + dy;
        if (valid(x2, y2)) add_edge(Z + i, g[x2][y2]);
      }
  vector<int> vS = get_comp(gS);
  vector<int> vT = get_comp(gT);
  for ((i) = 0; (i) < (int)(vS.size()); (i)++)
    if (vS[i] == gT) return true;
  for ((i) = 0; (i) < (int)(vS.size()); (i)++)
    for ((j) = 0; (j) < (int)(vT.size()); (j)++)
      if (connected_weakly(vS[i], vT[j])) return true;
  return false;
}
int get_id(int x, int y) { return x * Y + y; }
void pre(void) {
  int i, j, dx, dy;
  init(X * Y + 2);
  int S = X * Y;
  int T = X * Y + 1;
  for ((i) = 0; (i) < (int)(X); (i)++)
    for ((j) = 0; (j) < (int)(Y); (j)++)
      for (dx = -1; dx <= 1; dx++)
        for (dy = -1; dy <= 1; dy++) {
          int x1 = i;
          int y1 = j;
          int x2 = i + dx;
          int y2 = j + dy;
          if (valid(x1, y1) && valid(x2, y2))
            connect(get_id(x1, y1), get_id(x2, y2));
        }
  for ((i) = 0; (i) < (int)(X); (i)++)
    for ((j) = 0; (j) < (int)(Y); (j)++)
      if (valid(i, j)) {
        if (i == 0 || j == Y - 1) connect(get_id(i, j), S);
        if (i == X - 1 || j == 0) connect(get_id(i, j), T);
      }
  gS = root(S);
  gT = root(T);
  for ((i) = 0; (i) < (int)(X); (i)++)
    for ((j) = 0; (j) < (int)(Y); (j)++) g[i][j] = -1;
  for ((i) = 0; (i) < (int)(X); (i)++)
    for ((j) = 0; (j) < (int)(Y); (j)++)
      if (valid(i, j)) g[i][j] = root(get_id(i, j));
  for ((i) = 0; (i) < (int)(X); (i)++)
    for ((j) = 0; (j) < (int)(Y); (j)++)
      for (dx = -2; dx <= 2; dx++)
        for (dy = -2; dy <= 2; dy++) {
          int x1 = i;
          int y1 = j;
          int x2 = i + dx;
          int y2 = j + dy;
          if (valid(x1, y1) && valid(x2, y2)) {
            int p = root(get_id(x1, y1));
            int q = root(get_id(x2, y2));
            if (p != q) {
              if (p > q) swap(p, q);
              weak_edge.insert(make_pair(p, q));
            }
          }
        }
  for ((i) = 0; (i) < (int)(X); (i)++)
    for ((j) = 0; (j) < (int)(Y); (j)++)
      if (valid(i, j)) {
        if (i <= 1 || j >= Y - 2) {
          int p = root(get_id(i, j));
          int q = gS;
          if (p != q) {
            if (p > q) swap(p, q);
            weak_edge.insert(make_pair(p, q));
          }
        }
        if (i >= X - 2 || j <= 1) {
          int p = root(get_id(i, j));
          int q = gT;
          if (p != q) {
            if (p > q) swap(p, q);
            weak_edge.insert(make_pair(p, q));
          }
        }
      }
}
int main(void) {
  int i, j;
  cin >> X >> Y >> Q;
  for ((i) = 0; (i) < (int)(X); (i)++) scanf("%s", board[i]);
  pre();
  for ((i) = 0; (i) < (int)(Q); (i)++) {
    bool ans = query();
    if (ans)
      printf("NO\n");
    else
      printf("YES\n");
    fflush(stdout);
  }
  return 0;
}
