bool mem_st; 
#include<bits/stdc++.h>
using namespace std;
#define MAXN 100005
int n,m,q;
vector<int>g[MAXN];
vector<int>rlim[MAXN];
bool has_lim[MAXN];
int fa[MAXN];
namespace get_tree{
	int d[MAXN];
	vector<int>revg[MAXN];
	int f[18][MAXN];
	int dep[MAXN];
	int lca(int u,int v){
		if(dep[u]<dep[v])swap(u,v);
		for(int j=17;j>=0;--j){
			if(dep[f[j][u]]>=dep[v])
			u=f[j][u];
		}
		if(u==v)return u;
		for(int j=17;j>=0;--j){
			if(f[j][u]!=f[j][v]){
				u=f[j][u];
				v=f[j][v];
			}
		}
		return f[0][u];
	}
	bool vis[MAXN];
	void dfs(int u,int rt){
		if(vis[u])return;
		vis[u]=true;
		if(u!=rt)rlim[rt].emplace_back(u);
		for(auto v:revg[u]){
			dfs(v,rt);
		}
	}
	void work(){
		for(int i=1;i<=n;++i){
			for(auto v:g[i]){
				++d[v];
				revg[v].emplace_back(i);
			}
		}
		queue<int>q;
		q.push(1);
		int u;
		while(!q.empty()){
			u=q.front();q.pop();
//			cerr<<'!'<<u<<endl;
			if(u!=1){
				int v=revg[u][0];
				for(int i=1;i<revg[u].size();++i){
					v=lca(v,revg[u][i]);
				}
				if(revg[u].size()>1){
					has_lim[u]=true;
					for(int i=1;i<=n;++i)vis[i]=false;
					vis[v]=true;
					dfs(u,u);
				}
				f[0][u]=v;
				fa[u]=v;
				dep[u]=dep[v]+1;
				for(int j=1;j<18;++j){
					f[j][u]=f[j-1][f[j-1][u]];
				}
			}
			else{
				f[0][1]=1;
				for(int j=1;j<18;++j){
					f[j][1]=f[j-1][f[j-1][1]];
				}
			}
			for(auto v:g[u]){
				--d[v];
				if(!d[v])q.push(v);
			}
		}
	}
}
int k;
vector<int>e[MAXN];
pair<int,int>f[19][2*MAXN];
int lg2[2*MAXN],cnt=0;
int dep[MAXN],id[MAXN];
int dfn[MAXN],tot=0;
int lca(int u,int v){
	u=id[u],v=id[v];
	if(u>v)swap(u,v);
	int t=lg2[v-u+1];
	return min(f[t][u],f[t][v-(1<<t)+1]).second;
}
void dfs2(int u){
	dfn[u]=++tot;
	for(auto v:e[u]){
		dep[v]=dep[u]+1;
		id[v]=++cnt;
		f[0][cnt]=make_pair(dep[v],v);
		dfs2(v);
		id[u]=++cnt;
		f[0][cnt]=make_pair(dep[u],u);
	}
}
inline bool cmp(int x,int y){
	return dfn[x]<dfn[y];
}
const int mxk=4;
struct poly{
	long long f[mxk+1];
	inline void clear(){
		memset(f,0,sizeof(f));
	}
};
poly ff[MAXN];
poly operator*(const poly&a,const poly&b){
	poly c={{0}};
	for(int i=0;i<=k;++i){
		for(int j=0;i+j<=k;++j){
			c.f[i+j]+=a.f[i]*b.f[j];
		}
	}
	return c;
}
namespace tree_cut{
	int sz[MAXN],bs[MAXN];
	void dfs1(int u){
		sz[u]=1;
		int mx=0;
		for(auto v:e[u]){
			dfs1(v);
			if(sz[v]>mx){
				mx=sz[v];
				bs[u]=v;
			}
			sz[u]+=sz[v];
		}
	}
	int id[MAXN],top[MAXN],tot=0;
	void dfs2(int u,int tp){
		id[u]=++tot;
		top[u]=tp;
		if(bs[u])dfs2(bs[u],tp);
		for(auto v:e[u])if(v!=bs[u]){
			dfs2(v,v);
		}
	}
	struct node{
		int s;
		int tg;
	}tr[MAXN<<2];
	inline void pushup(int rt,int l,int r){
		if(tr[rt].tg){
			tr[rt].s=0;
		}
		else{
			if(l==r)tr[rt].s=1;
			else tr[rt].s=tr[rt<<1].s+tr[rt<<1|1].s;
		}
	}
	void build(int rt,int l,int r){
		tr[rt].s=r-l+1;
		if(l==r)return;
		int mid=(l+r)>>1;
		build(rt<<1,l,mid);
		build(rt<<1|1,mid+1,r);
	}
	void init(){
		dfs1(1);
		dfs2(1,1);
		build(1,1,n);
	}
	void update(int rt,int l,int r,int x,int y,int v){
		if(r<x||l>y)return;
		if(x<=l&&r<=y){
			tr[rt].tg+=v;
			pushup(rt,l,r);
			return;
		}
		int mid=(l+r)>>1;
		update(rt<<1,l,mid,x,y,v);
		update(rt<<1|1,mid+1,r,x,y,v);
		pushup(rt,l,r);
	}
	int query(int rt,int l,int r,int x,int y){
		if(r<x||l>y||(tr[rt].tg))return 0;
		if(x<=l&&r<=y)return tr[rt].s;
		int mid=(l+r)>>1;
		return query(rt<<1,l,mid,x,y)+query(rt<<1|1,mid+1,r,x,y);
	}
	void upd(int x,int f,int v){
		// f in path
		for(;x&&top[x]!=top[f];x=fa[top[x]]){
			update(1,1,n,id[top[x]],id[x],v);
		}
		update(1,1,n,id[f],id[x],v);
	}
	int qq(int x,int f){
		// f not in path
		int r=0;
		for(;x&&top[x]!=top[f];x=fa[top[x]]){
			r+=query(1,1,n,id[top[x]],id[x]);
		}
		if(x!=f){
			r+=query(1,1,n,id[f]+1,id[x]);
		}
		return r;
	}
}
bool is_nd[MAXN];
void dfs3(int u,int fa){
	ff[u].clear();
	if(!is_nd[u]){
		if(!g[u].empty())ff[u].f[0]=1;
		for(auto v:g[u]){
			dfs3(v,u);
			ff[u]=ff[u]*ff[v];
		}
	}
	int c=tree_cut::qq(u,fa);
//	cout<<u<<':'<<fa<<' '<<c<<endl;
	ff[u].f[1]+=c;
}
int s[MAXN],tt[MAXN];
vector<pair<int,int> >lims[MAXN];
vector<int>fa_lim[MAXN];
void dfs5(int u){
	if(!lims[u].empty())fa_lim[u].emplace_back(u);
	for(auto v:e[u]){
		fa_lim[v]=fa_lim[u];
		dfs5(v);
	}
}
void dfs4(int u,int rt){
	int c=s[u];
	for(auto v:e[u]){
		dfs4(v,rt);
		if(tt[v]){
			if(c){
				--c;
				tt[u]=tt[v];
			}
			else{
				lims[rt].push_back(make_pair(tt[v],v));
			}
		}
	}
	if(c)tt[u]=u;
}
bool mem_ed;
signed main(){
//	cerr<<(&mem_st-&mem_ed)/1048576.0<<'\n';
//	freopen("lodge.in","r",stdin);
//	freopen("lodge.out","w",stdout);
	ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);
	cin>>n>>m>>q;
	for(int i=1,u,v;i<=m;++i){
		cin>>u>>v;
		g[u].emplace_back(v);
	}
	get_tree::work();
	for(int i=1;i<=n;++i){
		if(fa[i]){
			e[fa[i]].emplace_back(i);
//			cerr<<fa[i]<<' '<<i<<'\n';
		}
	}
	for(int i=1;i<=n;++i)if(has_lim[i]){
		for(int j=1;j<=n;++j)tt[j]=0;
		for(auto it:rlim[i])s[it]=1;
		dfs4(1,i);
		if(tt[1]){
			lims[i].push_back(make_pair(tt[1],1));
		}
		for(auto it:rlim[i])s[it]=0;
//		cerr<<"lim "<<i<<':';
//		for(auto it:lims[i]){
//			cerr<<'('<<it.first<<','<<it.second<<')'<<' ';
//		}
//		cerr<<'\n';
	}
	tree_cut::init();
	dep[1]=1;
	dfs2(1);
	dfs5(1);
	for(int i=2;i<=2*n;++i){
		lg2[i]=lg2[i>>1]+1;
	}
	for(int j=1;j<19;++j){
		for(int i=1;i+(1<<j)-1<=cnt;++i){
			f[j][i]=min(f[j-1][i],f[j-1][i+(1<<(j-1))]);
		}
	}
	for(int i=1;i<=n;++i)g[i].clear();
	vector<int>tmp,tmp3,tmp2;
	tmp.reserve(5);
	tmp3.reserve(5);
	int c,x;
	for(int tc=1;tc<=q;++tc){
		cin>>k>>c;
		tmp.clear();
		tmp2.clear();
		tmp3.clear();
		for(int i=1;i<=c;++i){
			cin>>x;
			tmp.emplace_back(x);
			tmp3.push_back(x);
			is_nd[x]=true;
		}
		for(auto x:tmp3){
			for(auto it:fa_lim[x]){
				tmp2.push_back(it);
			}
		}
		sort(tmp2.begin(),tmp2.end());
		tmp2.resize(unique(tmp2.begin(),tmp2.end())-tmp2.begin());
		for(auto x:tmp2){
			for(auto it:lims[x]){
				tree_cut::upd(it.first,it.second,1);
			}
		}
		sort(tmp.begin(),tmp.end(),cmp);
		for(int i=0,u=tmp.size();i+1<u;++i){
			tmp.emplace_back(lca(tmp[i],tmp[i+1]));
		}
		sort(tmp.begin(),tmp.end(),cmp);
		tmp.resize(unique(tmp.begin(),tmp.end())-tmp.begin());
		for(int i=0;i+1<tmp.size();++i){
			g[lca(tmp[i],tmp[i+1])].emplace_back(tmp[i+1]);
		}
		
		int rt=tmp[0];
		dfs3(rt,0);
		cout<<ff[rt].f[k]<<'\n';
		
		for(auto it:tmp)g[it].clear();
		for(auto x:tmp3)is_nd[x]=false;
		for(auto x:tmp2){
			for(auto it:lims[x]){
				tree_cut::upd(it.first,it.second,-1);
			}
		}
	}
}
/*
8 9 4
 1 2
 1 3
 3 6
 6 8
 2 4
 2 5
 4 7
 5 7
 7 8
 2 3 4 5 6
 2 2 6 8
 1 1 6
 1 1 8
*/