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

typedef pair<int,int> pii;
#define x first
#define y second
const int maxn=2e6+10;

inline int read(){
    int x=0,w=1;char c=getchar();
    while(c<'0'||c>'9'){if(c=='-')w=-1;c=getchar();}
    while(c<='9'&&c>='0'){x=(x<<3)+(x<<1)+c-'0';c=getchar();}
    return x*w;
}

int t;
int n,m;
pii S[maxn],T[maxn];
int st[maxn];
// 0 neither
// 1 u
// 2 v
// 3 both
struct edge{
    int to,nxt,id;
}e[maxn<<1];
int head[maxn],cnt;
int deg[maxn];
bool self_loop[maxn];
inline void add_edge(int u,int v,int id){
    e[++cnt].to=v,e[cnt].nxt=head[u],e[cnt].id=id,head[u]=cnt;
    e[++cnt].to=u,e[cnt].nxt=head[v],e[cnt].id=id,head[v]=cnt;
}
bool vis[maxn];
int cntnode,cntdeg;
bool chkself_loop;
struct Edge{
    int u,v,id;
    Edge()=default;
    Edge(int u_,int v_,int id_):u(u_),v(v_),id(id_){}
};
vector<int> N;
vector<Edge> E;
void dfs_deg(int u){
    vis[u]=1;
    ++cntnode,cntdeg+=deg[u],chkself_loop|=self_loop[u];
    N.push_back(u);
    for(int i=head[u];i;i=e[i].nxt){
        int v=e[i].to,id=e[i].id;
        E.push_back(Edge(u,v,id));
        if(vis[v]) continue;
        dfs_deg(v);
    }
}

int ans;

namespace PseudoTree{
    vector<int> loopN;
    vector<Edge> loopE;
    int fa[maxn];
    int mark1,mark2;
    bool marknode[maxn],markedge[maxn];
    void find_loop(int u,int f,int last){
        if(!fa[u]) fa[u]=f;
        else{
            if(!mark1&&!mark2) mark1=u,mark2=f;
            return;
        }
        for(int i=head[u];i;i=e[i].nxt){
            int v=e[i].to;
            if(i==(last^1)) continue;
            find_loop(v,u,i);
        }
    }
    void dfs(int u,int f){
        fa[u]=f;
        for(int i=head[u];i;i=e[i].nxt){
            int v=e[i].to;
            if(v==f||marknode[v]) continue;
            dfs(v,u);
        }
    }
    inline void solve(int rt){
        int res=0;
        loopN.clear(),loopE.clear();
        for(int u:N) marknode[u]=0;
        for(Edge i:E) markedge[i.id]=0;
        if(chkself_loop){
            for(int u:N){
                if(self_loop[u]){
                    marknode[u]=1;
                    dfs(u,0);
                }
            }
            for(Edge i:E){
                if(i.u>i.v) continue;
                if(markedge[i.id]) continue;
                if(i.u==i.v) res+=st[i.id];
                else{
                    if(fa[i.u]==i.v&&(st[i.id]==1||st[i.id]==3)) ++res;
                    if(fa[i.v]==i.u&&(st[i.id]==2||st[i.id]==3)) ++res; 
                }
                markedge[i.id]=1;
            }
        }
        else{
            for(int u:N) fa[u]=0;
            for(Edge i:E) markedge[i.id]=0;
            mark1=0,mark2=0;
            find_loop(rt,m+1,0);
            int now=mark2,last=0;
            while(1){
                loopN.push_back(now);
                marknode[now]=1;
                for(int i=head[now];i;i=e[i].nxt){
                    int v=e[i].to;
                    if(v==last&&!markedge[e[i].id]){
                        loopE.push_back(Edge(last,now,e[i].id));
                        markedge[e[i].id]=1;
                        break;
                    }
                }
                if(now==mark1) break;
                last=now,now=fa[now];
            }
            for(int i=head[mark1];i;i=e[i].nxt){
                int v=e[i].to;
                if(v==mark2&&!markedge[e[i].id]){
                    loopE.push_back(Edge(mark1,mark2,e[i].id));
                    markedge[e[i].id]=1;
                    break;
                }
            }
            for(int u:loopN) dfs(u,0);
            for(Edge i:E){
                if(i.u>i.v) continue;
                if(markedge[i.id]) continue;
                if(fa[i.u]==i.v&&(st[i.id]==1||st[i.id]==3)) ++res;
                if(fa[i.v]==i.u&&(st[i.id]==2||st[i.id]==3)) ++res;
                markedge[i.id]=1;
            }
            int cnt1=0,cnt2=0,cnt3=0;
            for(Edge i:loopE){
                if(st[i.id]==1){
                    if(i.u<i.v) ++cnt1;
                    else ++cnt2;
                }
                else if(st[i.id]==2){
                    if(i.u<i.v) ++cnt2;
                    else ++cnt1;
                }
                else if(st[i.id]==3) ++cnt3;
            }
            if(cnt1+cnt3<cnt2) res+=(cnt1+cnt3);
            else if(cnt2+cnt3<cnt1) res+=(cnt2+cnt3);
            else res+=(cnt1+cnt2+cnt3)/2;
        }
        ans+=res;
    }
}

namespace Tree{
    int fa[maxn],siz[maxn],dfn[maxn],dfncnt;
    void dfs1(int u,int f){
        fa[u]=f,siz[u]=1,dfn[u]=++dfncnt;
        for(int i=head[u];i;i=e[i].nxt){
            int v=e[i].to;
            if(v==f) continue;
            dfs1(v,u);
            siz[u]+=siz[v];
        }
    }
    int sum[maxn];
    inline void add(int l,int r){
        if(l>r) return;
        ++sum[l],--sum[r+1];
    }
    int cntedge;
    int f[maxn][2];
    int D;
    void dfs2(int u){
        f[u][0]=f[u][1]=sum[dfn[u]];
        for(int i=head[u];i;i=e[i].nxt){
            int v=e[i].to,w=(st[e[i].id]==3);
            if(v==fa[u]) continue;
            dfs2(v);
            if(f[v][0]+w>f[u][0]) f[u][1]=f[u][0],f[u][0]=f[v][0]+w;
            else if(f[v][0]+w>f[u][1]) f[u][1]=f[v][0]+w;
        }
        D=max(D,f[u][0]+f[u][1]);
    }
    inline void solve(int rt){
        dfncnt=0;
        for(int u:N) fa[u]=0,siz[u]=0,dfn[u]=0;
        dfs1(rt,0);
        for(int i=1;i<=dfncnt;++i) sum[i]=0;
        cntedge=0;
        for(Edge i:E){
            if(i.u>i.v) continue;
            if(st[i.id]==1){
                ++cntedge;
                if(fa[i.u]==i.v) add(dfn[i.u],dfn[i.u]+siz[i.u]-1);
                if(fa[i.v]==i.u) add(1,dfn[i.v]-1),add(dfn[i.v]+siz[i.v],dfncnt);
            }
            else if(st[i.id]==2){
                ++cntedge;
                if(fa[i.u]==i.v) add(1,dfn[i.u]-1),add(dfn[i.u]+siz[i.u],dfncnt);
                if(fa[i.v]==i.u) add(dfn[i.v],dfn[i.v]+siz[i.v]-1);
            }
            else if(st[i.id]==3) ++cntedge;
        }
        for(int i=1;i<=dfncnt;++i) sum[i]+=sum[i-1];
        for(int u:N) f[u][0]=f[u][1]=0;
        D=0;
        dfs2(rt);
        ans+=cntedge-D/2-((D&1)?1:0);
    }
}

int main(){
    // freopen("game.in","r",stdin);
    // freopen("game.out","w",stdout);
    t=read();
    while(t--){
        n=read(),m=read();
        for(int i=1;i<=n;++i){
            S[i]=make_pair(0,0),T[i]=make_pair(0,0);
            st[i]=0;
        }
        cnt=1;
        for(int i=1;i<=m;++i){
            head[i]=0,deg[i]=0,self_loop[i]=0,vis[i]=0;
        }
        for(int i=1;i<=n;++i){
            int k=read();
            S[i].x=read();
            if(k==2){
                S[i].y=read();
                if(S[i].x>S[i].y) swap(S[i].x,S[i].y);
            }
        }
        for(int i=1;i<=n;++i){
            int k=read();
            T[i].x=read();
            if(k==2){
                T[i].y=read();
                if(T[i].x>T[i].y) swap(T[i].x,T[i].y);
            }
        }
        for(int i=1;i<=n;++i){
            bool chk0=0,chk1=0;
            if(S[i].x==T[i].x||S[i].y==T[i].x) chk0=1;
            if(T[i].y&&(S[i].x==T[i].y||S[i].y==T[i].y)) chk1=1;
            if(chk0&&chk1) st[i]=3;
            else if(chk0) st[i]=1;
            else if(chk1) st[i]=2;
            else st[i]=0;
        }
        for(int i=1;i<=n;++i){
            if(!T[i].y){
                deg[T[i].x]+=2;
                self_loop[T[i].x]=1;
                add_edge(T[i].x,T[i].x,i);
            }
            else{
                ++deg[T[i].x],++deg[T[i].y];
                add_edge(T[i].x,T[i].y,i);
            }
        }
        bool chk=1;
        ans=0;
        for(int i=1;i<=m;++i){
            if(vis[i]) continue;
            if(!deg[i]) continue;
            cntnode=0,cntdeg=0,chkself_loop=0;
            N.clear(),E.clear();
            dfs_deg(i);
            if(cntdeg/2>cntnode){
                chk=0;
                break;
            } 
            else if(cntdeg/2==cntnode) PseudoTree::solve(i);
            else if(cntdeg/2==cntnode-1) Tree::solve(i);
        }
        if(!chk) printf("-1\n");
        else printf("%d\n",ans);
    }
    return 0;
}