#include <bits/stdc++.h>
using namespace std;
#define int long long
vector<int> pre, post;
vector<vector<pair<int,int>>> adj;
vector<int> bt;
vector<int> deg;
vector<pair<int,int>> par;
int rev[4]={0,2,1,3};

struct seg {
  int n, h; vector<int> v, lazy;
  seg(int _n): n(_n), v(2*_n,0), lazy(_n,0), h(64-__builtin_clzll(_n)) {}
  void app(int x, int k) {
    v[x] += k;
    if(x<n) lazy[x] += k;
  }
  void build(int x) {for(x+=n;x>>=1;) v[x]=min(v[x<<1],v[x<<1|1])+lazy[x];}
  void push(int x) {
    for(int s=h;s;--s) {
      int k = (x >> s);
      app(k<<1,lazy[k]);
      app(k<<1|1,lazy[k]);
      lazy[k]=0;
    }
  }
  void up(int l, int r, int u) {
    int l0 = l, r0 = r;
    for(l+=n,r+=n;l<r;l>>=1,r>>=1) {
      if(l&1) app(l++,u);
      if(r&1) app(--r,u);
    }
    build(l0); build(r0-1);
  }
  int qry(int l, int r) {
    push(l); push(r-1);
    int ans = 1e9;
    for(l+=n,r+=n;l<r;l>>=1,r>>=1) {
      if(l&1) ans = min(ans,v[l++]);
      if(r&1) ans = min(ans,v[--r]);
    }
    return ans;
  }
};

int cnt;
void dfs0(int x, int p) {
  pre[x]=cnt++;
  for(auto [i,id]: adj[x]) if(i!=p) dfs0(i,x);
  post[x] = cnt;
}

int dfs1(int x, int p, seg &s) {
  int ans = s.qry(0,s.n);
  for(auto [i,id]: adj[x]) if(i!=p) {
    if(id==3) {
      s.up(0,s.n,-1);
      s.up(pre[i],post[i],2);
    }
    ans = max(ans,dfs1(i,x,s));
    if(id==3) {
      s.up(0,s.n,1);
      s.up(pre[i],post[i],-2);
    }
  }
  return ans;
}

int solve_tree(int rt) {
  cnt = 0;
  dfs0(rt,-1);

  seg s(cnt);
  stack<int> st;
  for(st.push(rt);st.size();) {
    int x = st.top(); st.pop();
    for(auto [i,id]: adj[x]) if(pre[i]>pre[x]) {
      st.push(i);
      if(id&2) s.up(0,s.n,1), s.up(pre[i],post[i],-1);
      else if(id) s.up(pre[i],post[i],1);
    }
  }

  return dfs1(rt,-1,s);
}

void dfs2(int x, vector<int> &v) {
  v.push_back(x);
  pre[x]=0;
  for(auto [i,id]: adj[x]) if(pre[i]) deg[i]++,deg[x]++,dfs2(i,v);
}

void dfs3(int x) {
  pre[x]=1;
  for(auto [i,id]: adj[x]) if(i>=0&&!pre[i]) {par[i]={x,rev[id]}; dfs3(i);}
}

int solve_cycle(int rt) {
  vector<int> v;
  dfs2(rt,v);

  int cyc0 = -1, cyc1 = -1;
  for(auto i: v) if(deg[i]<adj[i].size()) {if(cyc0==-1) cyc0=i; else cyc1=i;}
  if(cyc1==-1) cyc1=cyc0;
  for(auto &[i,id]: adj[cyc0]) if(i==cyc1) {i=~i; break;}
  dfs3(cyc0);

  int ans = 0, a = 0, b = 0, c = 0;
  for(auto i: v) if(i!=cyc0 && (par[i].second&1)) ans++;
  for(int i=cyc1;i!=cyc0;i=par[i].first) {
    if(par[i].second&1) ans--;
    if(par[i].second==1) a++;
    if(par[i].second==2) b++;
    if(par[i].second==3) c++;
  }
  for(auto [i,id]: adj[cyc0]) if(i<0) {
    if(id==1) a++;
    if(id==2) b++;
    if(id==3) c++;
  }

  return ans + (cyc0==cyc1&&a+b+c?1:min({a+c,b+c,(a+b+c)/2}));
}

vector<int> a, b;
int solve(int n, int m) {
  adj.resize(m);
  for(int i=0;i<m;i++) adj[i].clear();
  pre.resize(m); post.resize(m);
  for(int i=0;i<m;i++) pre[i]=-1;
  deg.resize(m);
  for(int i=0;i<m;i++) deg[i]=0;
  par.resize(m);

  vector<int> par(m), sz(m,1), edges(m,0);
  iota(par.begin(),par.end(),0);
  auto onion = [&par](auto &onion, int x) -> int {return par[x]=(par[x]==x?x:onion(onion,par[x]));};
  auto merge = [&onion,&par,&sz,&edges](int x, int y) {
    x = onion(onion,x);
    y = onion(onion,y);
    if(sz[x]>sz[y]) swap(x,y);
    edges[y]++;
    if(x==y) return 0;
    par[x]=y;
    sz[y]+=sz[x];
    edges[y]+=edges[x];
    return 1;
  };
  for(int i=0;i<n;i++) {
    adj[a[i]].push_back({b[i],bt[i]});
    adj[b[i]].push_back({a[i],rev[bt[i]]});
    merge(a[i],b[i]);
  }
  int ans = 0;
  for(int i=0;i<m;i++) if(par[i]==i) {
    int net = edges[i]-sz[i];
    if(net&&(~net)) return -1;
    if(net) ans += solve_tree(i);
    else ans += solve_cycle(i);
  }
  return ans;
}
main() {
  ios_base::sync_with_stdio(0); cin.tie(0);
  int t; cin >> t; while(t--) {
    int n, m; cin >> n >> m;
    a.resize(n); b.resize(n);
    vector<pair<int,int>> s(n);
    bt.resize(n);
    for(int i=0,sz;i<n;i++) {
      cin >> sz >> s[i].first;
      if(sz==2) cin>>s[i].second; else s[i].second=s[i].first;
      s[i].first--; s[i].second--;
    }
    for(int i=0,sz;i<n;i++) {
      cin >> sz >> a[i];
      if(sz==2) cin>>b[i]; else b[i]=a[i];
      a[i]--; b[i]--;
      bt[i] = 0;
      bt[i]|=(a[i]==s[i].first||a[i]==s[i].second);
      bt[i]|=((b[i]==s[i].first||b[i]==s[i].second)<<1);
    }
    cout << solve(n,m)<<"\n";
  }
}