#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)) {}
	inline void app(int x, int k) {
		v[x] += k;
		if(x<n)
			lazy[x] += k;
	}
	inline void build(int x) {
		for(x+=n;x>>=1;)
			v[x]=min(v[x<<1],v[x<<1|1])+lazy[x];
	}
	inline 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;
		}
	}
	inline 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);
	}
	inline 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;
}

inline void proc(int i, int edgeBitmask, seg &s) {
	if(edgeBitmask&2)
		s.up(0,s.n,1),
		s.up(pre[i],post[i],-1);
	else if(edgeBitmask)
		s.up(pre[i],post[i],1);
}
inline 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);
			proc(i,id,s);
		}
	}

	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);
	}
}

inline 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 {
		if(par[x]==x) 
			return x;
		return par[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;
}
inline void readSt(int &a, int &b) {
	int sz;
	cin >> sz >> a;
	if(sz==2)
		cin >> b;
	else
		b = a;
	--a; --b;
}
inline int btmsk(int s0, int s1, int t0, int t1) {
	int ans = 0;
	if(t0==s0||t0==s1)
		ans |= 1;
	if(t1==s0||t1==s1)
		ans |= 2;
	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++)
			readSt(s[i].first,s[i].second);
		for(int i=0,sz;i<n;i++) {
			readSt(a[i],b[i]);
			bt[i] = btmsk(s[i].first,s[i].second,a[i],b[i]);
		}
		cout << solve(n,m)<<"\n";
	}
}