#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 3;
int pre[MAXN], post[MAXN];
vector<pair<int,int>> adj[MAXN];
int bt[MAXN];
int deg[MAXN];
pair<int,int> par[MAXN];
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(32-__builtin_clz(_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}));
}

int a[MAXN], b[MAXN];
int solve(int n, int m) {
	for(int i=0;i<m;i++)
		adj[i].clear(),
		pre[i]=-1,
		deg[i]=0;
	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;
		pair<int,int> s[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";
	}
}