#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
const int N = 104;
const int S = 52;
const ull INF = -1;
template <class T>
void umin(T &a, T b) {
  a = min(a, b);
}
int tr[S][2];
int go[S][2];
int ls[S];
int pr[S];
int pi[S];
bool z[S];
int len = 0;
void add(vector<int> s) {
  int v = 0;
  for (int c : s) {
    if (tr[v][c] == -1) {
      tr[v][c] = ++len;
      assert(len < S);
      pr[len] = v;
      ls[len] = c;
    }
    v = tr[v][c];
  }
  z[v] = true;
}
void build() {
  pr[0] = -1;
  ls[0] = -1;
  queue<int> q;
  q.push(0);
  while (q.size()) {
    int v = q.front();
    q.pop();
    pi[v] = (v && pr[v]) ? go[pi[pr[v]]][ls[v]] : 0;
    for (int c = 0; c < 2; ++c) {
      if (tr[v][c] != -1) {
        go[v][c] = tr[v][c];
        q.push(tr[v][c]);
      } else {
        go[v][c] = v ? go[pi[v]][c] : 0;
      }
    }
  }
  for (int i = 0; i <= len; ++i) {
    if (z[i] |= z[pi[i]]) {
      go[i][0] = i;
      go[i][1] = i;
    }
  }
}
int g;
int n;
int m;
int a[N], k[N], b[N][N];
ull dp[N][S][S];
vector<pair<int, ull>> small[N][S];
ull tp[S][S];
bool relax(int row) {
  bool f = false;
  for (int i = 0; i < g; ++i) {
    for (int s = 0; s <= len; ++s) {
      small[i][s].clear();
      for (int t = 0; t <= len; ++t) {
        if (dp[i][s][t] < INF) {
          small[i][s].emplace_back(t, dp[i][s][t]);
        }
      }
    }
  }
  for (int st = 0; st <= len; ++st) {
    fill_n(tp[0], S * S, INF);
    tp[0][st] = 0;
    for (int ind = 0; ind < k[row]; ++ind) {
      int h = b[row][ind];
      for (int i = 0; i <= len; ++i) {
        if (tp[ind][i] >= INF) {
          continue;
        }
        for (auto e : small[h][i]) {
          umin(tp[ind + 1][e.first], tp[ind][i] + e.second);
        }
      }
    }
    for (int fn = 0; fn <= len; ++fn) {
      if (dp[a[row]][st][fn] > tp[k[row]][fn]) {
        dp[a[row]][st][fn] = tp[k[row]][fn];
        f = true;
      }
    }
  }
  return f;
}
signed main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  fill_n(tr[0], 2 * S, -1);
  fill_n(go[0], 2 * S, -1);
  fill_n(dp[0][0], N * S * S, INF);
  cin >> g >> n >> m;
  for (int i = 0; i < n; ++i) {
    cin >> a[i] >> k[i];
    for (int j = 0; j < k[i]; ++j) {
      cin >> b[i][j];
    }
  }
  for (int i = 0; i < m; ++i) {
    int l;
    cin >> l;
    vector<int> c(l);
    for (int &e : c) {
      cin >> e;
    }
    add(c);
  }
  build();
  for (int i = 0; i <= len; ++i) {
    cerr << i << " " << pi[i] << "\t";
    for (int h = 0; h < 2; ++h) {
      cerr << go[i][h] << " ";
      dp[h][i][go[i][h]] = 1;
    }
    cerr << endl;
  }
  for (int it = 0, run = true; it < g - 2 && run; ++it) {
    run = false;
    for (int i = 0; i < n; ++i) {
      run |= relax(i);
    }
  }
  for (int i = 2; i < g; ++i) {
    ull ans = INF;
    for (int j = 0; j <= len; ++j) {
      if (!z[j]) {
        umin(ans, dp[i][0][j]);
      }
    }
    if (ans < INF) {
      cout << "NO " << ans << "\n";
    } else {
      cout << "YES\n";
    }
  }
  return 0;
}
