#include <bits/stdc++.h>
using namespace std;

struct DSU {
  vector<int> fa, siz;
  DSU(int n = 0) : fa(n), siz(n, 1) {
    iota(fa.begin(), fa.end(), 0);
  }
  int find(int u) {
    while (u != fa[u]) {
      u = fa[u] = fa[fa[u]];
    }
    return u;
  }
  bool merge(int u, int v) {
    u = find(u);
    v = find(v);
    if (u == v) {
      return false;
    }
    fa[u] = v;
    siz[v] += siz[u];
    return true;
  }
};

const int N = 1e6 + 5;
int lim, mn[N << 2], tag[N << 2];
#define ls (2 * i)
#define rs (2 * i + 1)
#define mid ((l + r) / 2)
#define lp ls, l, mid
#define rp rs, mid, r
void pn(int i, int v) {
  mn[i] += v;
  tag[i] += v;
}
void down(int i) {
  if (tag[i]) {
    pn(ls, tag[i]);
    pn(rs, tag[i]);
    tag[i] = 0;
  }
}
void mdf(int ql, int qr, int v, int i = 1, int l = 0, int r = lim) {
  if (ql >= r || qr <= l) return;
  if (ql <= l && qr >= r) {
    pn(i, v);
    return;
  }
  down(i);
  mdf(ql, qr, v, lp);
  mdf(ql, qr, v, rp);
  mn[i] = min(mn[ls], mn[rs]);
}
int qry(int ql, int qr, int i = 1, int l = 0, int r = lim) {
  if (ql >= r || qr <= l) return 1e9;
  if (ql <= l && qr >= r) {
    return mn[i];
  }
  down(i);
  return min(qry(ql, qr, lp), qry(ql, qr, rp));
}
#undef mid

void solve() {
  int n, m;
  cin >> n >> m;
  vector<vector<int>> a(n), b(n), g(n);
  for (int i = 0, k, x; i < n; i++) {
    cin >> k;
    while (k--) {
      cin >> x;
      a[i].push_back(--x);
    }
  }
  DSU d(m);
  for (int i = 0, k, x; i < n; i++) {
    cin >> k;
    while (k--) {
      cin >> x;
      b[i].push_back(--x);
    }
    if (b[i].size() == 2) {
      d.merge(b[i][0], b[i][1]);
    }
    g[i].resize(b[i].size());
    for (int j = 0; j < g[i].size(); j++) {
      for (auto &y : a[i]) {
        if (y == b[i][j]) g[i][j] = 1;
      }
    }
  }
  vector<int> c(m), dg(m);
  vector<vector<pair<int, int>>> adj(m);
  for (int i = 0; i < n; i++) {
    int u = b[i][0];
    int v = b[i].size() == 1 ? u : b[i][1];
    c[d.find(u)]++;
    dg[u]++, dg[v]++;
    adj[u].push_back({v, i});
    if (u != v) adj[v].push_back({u, i});
  }
  int ans = 0;

  vector<int> is(n, 1), vis(m), got(m), ad(n);
  auto circle = [&](int s) {
    vector<int> ed, nd;
    queue<int> q;
    auto dfs = [&](auto self, int u)->void {
      got[u] = 1;
      for (auto [v, id] : adj[u]) {
        if (!ad[id]) {
          ad[id] = 1;
          ed.push_back(id);
        }
        if (!got[v])
          self(self, v);
      }
      if (dg[u] == 1) {
        q.push(u);
      }
      nd.push_back(u);
    };
    dfs(dfs, s);
    
    while (!q.empty()) {
      int u = q.front();
      q.pop();
      for (auto [v, id] : adj[u]) if (dg[v] > 1) {
        ans += g[id][v == b[id][0]];
        is[id] = 0;
        if (--dg[v] == 1) {
          q.push(v);
        }
      }
    }

    int res0 = 0, res1 = 0, cnt = 0;
    for (auto u : nd) if (dg[u] > 1) {
      s = u;
    }
    auto pdfs = [&](auto self, int u)->void {
      for (auto [v, id] : adj[u]) if (!vis[id] && dg[v] > 1) {
        vis[id] = 1;
        if (u == v) ans += g[id][0];
        else if (g[id][0] && g[id][1]) cnt++;
        else if (g[id][u == b[id][0]]) res0++;
        else if (g[id][v == b[id][0]]) res1++;
        self(self, v);
      }
    };
    pdfs(pdfs, s);
    if (res0 > res1) swap(res0, res1);
    ans += min((res0 + res1 + cnt) / 2, res0 + cnt);
  };

  vector<int> dfn(m), siz(m);
  auto tree = [&](int s) {
    if (d.siz[s] == 1) return;
    vector<int> ed;
    int ti = 0;
    auto dfs = [&](auto self, int u, int fa)->void {
      dfn[u] = ti++;
      siz[u] = 1;
      for (auto [v, id] : adj[u]) if (v != fa) {
        ed.push_back(id);
        self(self, v, u);
        siz[u] += siz[v];
      }
    };
    dfs(dfs, s, -1);

    lim = siz[s];
    fill(mn, mn + 4 * lim + 5, 0);
    fill(tag, tag + 4 * lim + 5, 0);

    vector<pair<int, int>> tmp;
    for (auto id : ed) {
      int u = b[id][0], v = b[id][1];
      int bu = g[id][0], bv = g[id][1];

      if (bu && bv) {
        tmp.push_back({u, v});
      } else {
        if (bv) {
          swap(u, v), swap(bu, bv);
        }
        if (!bu) continue;
        if (siz[u] > siz[v]) {
          mdf(dfn[v], dfn[v] + siz[v], 1);
        } else {
          mdf(0, dfn[u], 1);
          mdf(dfn[u] + siz[u], lim, 1);
        }
      }
    }
    for (auto &[u, v] : tmp) {
      if (siz[u] < siz[v]) swap(u, v);
      int v1 = qry(dfn[v], dfn[v] + siz[v]);
      if (v1 == mn[1]) {
        mdf(dfn[v], dfn[v] + siz[v], 1);
      } else {
        mdf(0, dfn[v], 1);
        mdf(dfn[v] + siz[v], lim, 1);
      }
    }
    ans += mn[1];
  };

  for (int i = 0; i < m; i++) if (d.find(i) == i) {
    if (d.siz[i] < c[i]) {
      cout << -1 << "\n";
      return;
    }
    d.siz[i] == c[i] ? circle(i) : tree(i);
  }
  cout << ans << "\n";
}

int main() {
  cin.tie(0)->sync_with_stdio(0);
  int t;
  cin >> t;
  while (t--) {
    solve();
  }
  return 0;
}