#include<cmath>

#include<queue>

#include<stack>

#include<cstdio>

#include<cctype>

#include<cstring>

#include<iostream>

#include<algorithm>

using namespace std;

typedef double dl;

const int N=2e5+;

const int B=;

const int M=N*;

inline int read(){

    int X=,w=;char ch=;

    while(!isdigit(ch)){w|=ch=='-';ch=getchar();}

    while(isdigit(ch))X=(X<<)+(X<<)+(ch^),ch=getchar();

    return w?-X:X;

}

struct node{

    int u[M],v[M],nxt[M];

    int cnt,head[N];

    void init(){

    cnt=;

    memset(head,,sizeof(head));

    }

    void add(int U,int V){

    u[++cnt]=U;v[cnt]=V;nxt[cnt]=head[U];head[U]=cnt;

    }

}e,g;

int n,m;

int dfn[N],low[N],to[N],t,l;

stack<int>q;

void tarjan(int u,int f){

    dfn[u]=low[u]=++t;

    for(int i=g.head[u];i;i=g.nxt[i]){

    int v=g.v[i];

    if(!dfn[v]){

        q.push(i);

        tarjan(v,u);

        low[u]=min(low[u],low[v]);

        if(low[v]>=dfn[u]){

        int num;l++;

        do{

            num=q.top();q.pop();

            int uu=g.u[num],vv=g.v[num];

            if(to[uu]!=l){

            to[uu]=l;

            e.add(uu,l+n);e.add(l+n,uu);

            }

            if(to[vv]!=l){

            to[vv]=l;

            e.add(vv,l+n);e.add(l+n,vv);

            }

        }while(num!=i);

        }

    }else if(low[u]>dfn[v]&&f!=v){

        q.push(i);

        low[u]=dfn[v];

    }

    }

}

int anc[N][B+],dep[N],pos[N],len[N],tot;

void dfs(int u,int f){

    pos[u]=++tot;

    dep[u]=dep[f]+;

    len[u]=len[f]+(u<=n);

    anc[u][]=f;

    for(int i=;i<=B;i++)

    anc[u][i]=anc[anc[u][i-]][i-];

    for(int i=e.head[u];i;i=e.nxt[i]){

    int v=e.v[i];

    if(v!=anc[u][])dfs(v,u);

    }

}

inline int LCA(int i,int j){

    if(dep[i]<dep[j])swap(i,j);

    for(int k=B;k>=;--k)

        if(dep[anc[i][k]]>=dep[j])i=anc[i][k];

    if(i==j)return i;

    for(int k=B;k>=;--k)

        if(anc[i][k]!=anc[j][k])

            i=anc[i][k],j=anc[j][k];

    return anc[i][];

}

int aux[N],stk[N],fa_aux[N],top,num;

bool cmp(int a,int b){return pos[a]<pos[b];}

int build(int t){

    sort(aux+,aux+t+,cmp);

    num=t;stk[top=]=;

    for(int i=;i<=t;i++){

        int u=aux[i];

        if(!top)fa_aux[u]=,stk[++top]=u;

        else{

            int lca=LCA(u,stk[top]);

            while(dep[stk[top]]>dep[lca]){

                if(dep[stk[top-]]<=dep[lca])

                    fa_aux[stk[top]]=lca;

                top--;

            }

            if(stk[top]!=lca){

                fa_aux[lca]=stk[top];

                stk[++top]=lca;

                aux[++num]=lca;

            }

            fa_aux[u]=lca;

            stk[++top]=u;

        }

    }

    sort(aux+,aux+num+,cmp);

}

int solve(){

    int ans=;

    for(int i=num;i>;i--){

    int u=aux[i],v=fa_aux[u];

    ans+=len[u]-len[v];

    }

    ans+=aux[]<=n;

    return ans;

}

inline void init(){

    t=l=tot=;

    e.init();g.init();

    memset(to,,sizeof(to));

    memset(dfn,,sizeof(dfn));

}

int main(){

    int T=read();

    while(T--){

    init();

    n=read(),m=read();

    for(int i=;i<=m;i++){

        int u=read(),v=read();

        g.add(u,v);g.add(v,u);

    }

    for(int i=;i<=n;i++)

        if(!dfn[i])tarjan(i,);

    dfs(,);

    int q=read();

    while(q--){

        int t=read();

        for(int i=;i<=t;i++)aux[i]=read();

        build(t);

        printf("%d\n",solve()-t);

    }

    }

    return ;

}