#ifndef LOCAL
#pragma GCC optimize ("Ofast")
#pragma GCC optimize ("unroll-loops")
#endif

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

using ll=long long;
using uint=unsigned;

#define rng(i,a,b) for(int i=int(a);i<int(b);i++)
#define rep(i,b) rng(i,0,b)
#define gnr(i,a,b) for(int i=int(b)-1;i>=int(a);i--)
#define per(i,b) gnr(i,0,b)

#define pb push_back
#define eb emplace_back
#define bg begin()
#define ed end()
#define all(x) x.bg,x.ed
#define si(x) int(x.size())

template<class t>using vc=vector<t>;
template<class t>using vvc=vc<vc<t>>;

using vi=vc<int>;

template<class t,class u>bool chmin(t&a,u b){
	if(a>b){a=b;return true;}
	else return false;
}
template<class t,class u>bool chmax(t&a,u b){
	if(a<b){a=b;return true;}
	else return false;
}

#define mp make_pair
#define a first
#define b second
using pi=pair<int,int>;

const int inf=INT_MAX/2-100;

const uint mod=998244353;
struct mint{
	uint v;
	mint(ll vv=0){s(vv%mod+mod);}
	mint&s(uint vv){
		v=vv<mod?vv:vv-mod;
		return *this;
	}
	mint operator-()const{return mint()-*this;}
	mint&operator+=(mint r){return s(v+r.v);}
	mint&operator-=(mint r){return s(v+mod-r.v);}
	mint&operator*=(mint r){v=(unsigned ll)v*r.v%mod;return *this;}
	mint&operator/=(mint r){return *this*=r.inv();}
	mint operator+(mint r)const{return mint(*this)+=r;}
	mint operator-(mint r)const{return mint(*this)-=r;}
	mint operator*(mint r)const{return mint(*this)*=r;}
	mint operator/(mint r)const{return mint(*this)/=r;}
	mint pow(ll n)const{
		if(n<0)return inv().pow(-n);
		mint res(1),x(*this);
		while(n){
			if(n&1)res*=x;
			x*=x;
			n>>=1;
		}
		return res;
	}
	mint inv()const{return pow(mod-2);}
};

struct unionfind{
	vi p,s;
	unionfind(int n):p(n,-1),s(n,1){}
	int find(int i){
		return p[i]==-1?i:p[i]=find(p[i]);
	}
	void unite(int a,int b){
		a=find(a);
		b=find(b);
		if(a==b)return;
		p[b]=a;
		s[a]+=s[b];
	}
};

template<class E>
struct HLD{
	vvc<E> g;
	int n,rt,cnt;
	vi sub,in,out,par,head,dep,hei,ni;
	vc<E> pe;
	int dfs1(int v,int p,int d){
		par[v]=p;
		dep[v]=d;
		
		for(auto&e:g[v]){
			pe[e]=e;
			sub[v]+=dfs1(e,v,d+1);
			if(sub[g[v][0]]<sub[e])
				swap(g[v][0],e);
		}
		return sub[v];
	}
	void dfs2(int v,int h){
		in[v]=cnt++;
		head[v]=h;
		for(int to:g[v])
			dfs2(to,to==g[v][0]?h:to);
		out[v]=cnt;
		if(si(g[v]))hei[v]=hei[g[v][0]]+1;
	}
	HLD(const vvc<E>&gg,int rr):g(gg),n(si(g)),rt(rr),cnt(0),
	sub(n,1),in(n),out(n),par(n,-1),head(n),dep(n),hei(n,1),ni(n),pe(n){
		dfs1(rt,-1,0);
		dfs2(rt,rt);
		rep(i,n)ni[in[i]]=i;
	}
	int lca(int a,int b){
		while(head[a]!=head[b]){
			if(dep[head[a]]>dep[head[b]])
				swap(a,b);
			b=par[head[b]];
		}
		if(dep[a]>dep[b])swap(a,b);
		return a;
	}
	vi index;
	pair<vi,vc<pi>> tree_compress(vi vs){
		if(si(index)==0)index.resize(n);
		assert(si(index));
		auto comp=[&](int x,int y){
			return in[x]<in[y];
		};
		sort(all(vs),comp);
		vs.erase(unique(all(vs)),vs.ed);
		int k=si(vs);
		rep(i,k-1)vs.pb(lca(vs[i],vs[i+1]));
		sort(all(vs),comp);
		vs.erase(unique(all(vs)),vs.ed);
		k=si(vs);
		rep(i,k)index[vs[i]]=i;
		vc<pi> es;
		rng(i,1,k){
			int p=lca(vs[i-1],vs[i]);
			es.eb(i,index[p]);
		}
		return mp(vs,es);
	}
};

void slv(){
	int n;cin>>n;
	vvc<int> t(2*n-1);
	unionfind uf(2*n-1);
	rng(i,n,2*n-1){
		int a,b;cin>>a>>b;
		a--;b--;
		a=uf.find(a);
		b=uf.find(b);
		t[i].pb(a);
		t[i].pb(b);
		uf.unite(i,a);
		uf.unite(i,b);
	}
	HLD<int> h(t,2*n-2);
	
	vvc<int> g;
	
	int q;cin>>q;
	rep(_,q){
		int k;cin>>k;
		vi vs(k);rep(i,k){cin>>vs[i];vs[i]--;}
		/*vc<pi>es;
		tie(vs,es)=h.tree_compress(vs);
		
		int s=si(vs);
		g.resize(s);
		rep(i,s)g[i].clear();
		//cerr<<_+1<<endl;
		//rep(i,s)cerr<<vs[i]<<" ";
		//cerr<<endl;
		rep(i,s-1){
			//cerr<<es[i].a<<" "<<es[i].b<<endl;
			g[es[i].b].pb(es[i].a);
		}
		using P=pair<mint,mint>;
		
		auto dfs=[&](auto self,int v,int p)->P{
			P res;
			if(g[v].empty()){
				res=P(0,1);
			}else{
				assert(si(g[v])==2);
				P a=self(self,g[v][0],v);
				P b=self(self,g[v][1],v);
				res.a=a.a*b.a;
				res.b=a.a*b.b+a.b*b.a;
			}
			if(p!=-1){
				int w=vs[p]-max(vs[v],n-1);
				res.a+=res.b*w;
			}
			return res;
		};
		P ans=dfs(dfs,0,-1);
		cout<<ans.b.v<<"\n";*/
		
		sort(all(vs),[&](int x,int y){return h.in[x]<h.in[y];});
		vi mn(k,2*n-1);
		rep(i,k-1){
			int v=h.lca(vs[i],vs[i+1]);
			chmin(mn[i],v);
			chmin(mn[i+1],v);
		}
		mint ans=1;
		rep(i,k)ans*=mn[i]-(n-1);
		cout<<ans.v<<'\n';
	}
}

signed main(){
	cin.tie(0);
	ios::sync_with_stdio(0);
	
	//int t;cin>>t;rep(_,t)
	slv();
}