#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("avx2,bmi,bmi2,lzcnt,popcnt")
#include <bits/stdc++.h>
using namespace std;
#define rep(i,a,n) for (int i=a;i<n;i++)
#define per(i,a,n) for (int i=n-1;i>=a;i--)
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define fi first
#define se second
#define SZ(x) ((int)(x).size())
typedef vector<int> VI;
typedef basic_string<int> BI;
typedef long long ll;
typedef pair<int,int> PII;
typedef double db;
mt19937 mrand(1); 
const ll mod=1000000007;
int rnd(int x) { return mrand() % x;}
ll powmod(ll a,ll b) {ll res=1;a%=mod; assert(b>=0); for(;b;b>>=1){if(b&1)res=res*a%mod;a=a*a%mod;}return res;}
ll gcd(ll a,ll b) { return b?gcd(b,a%b):a;}
// head

template<int MOD, int RT> struct mint {
	static const int mod = MOD;
	static constexpr mint rt() { return RT; } // primitive root for FFT
	int v; explicit operator int() const { return v; } // explicit -> don't silently convert to int
	mint():v(0) {}
	mint(ll _v) { v = int((-MOD < _v && _v < MOD) ? _v : _v % MOD);
		if (v < 0) v += MOD; }
	bool operator==(const mint& o) const {
		return v == o.v; }
	friend bool operator!=(const mint& a, const mint& b) { 
		return !(a == b); }
	friend bool operator<(const mint& a, const mint& b) { 
		return a.v < b.v; }
   
	mint& operator+=(const mint& o) { 
		if ((v += o.v) >= MOD) v -= MOD; 
		return *this; }
	mint& operator-=(const mint& o) { 
		if ((v -= o.v) < 0) v += MOD; 
		return *this; }
	mint& operator*=(const mint& o) { 
		v = int((ll)v*o.v%MOD); return *this; }
	mint& operator/=(const mint& o) { return (*this) *= inv(o); }
	friend mint pow(mint a, ll p) {
		mint ans = 1; assert(p >= 0);
		for (; p; p /= 2, a *= a) if (p&1) ans *= a;
		return ans; }
	friend mint inv(const mint& a) { assert(a.v != 0); 
		return pow(a,MOD-2); }
		
	mint operator-() const { return mint(-v); }
	mint& operator++() { return *this += 1; }
	mint& operator--() { return *this -= 1; }
	friend mint operator+(mint a, const mint& b) { return a += b; }
	friend mint operator-(mint a, const mint& b) { return a -= b; }
	friend mint operator*(mint a, const mint& b) { return a *= b; }
	friend mint operator/(mint a, const mint& b) { return a /= b; }
};

const int MOD=1000000007; 
using mi = mint<MOD,5>; // 5 is primitive root for both common mods

namespace simp {
	vector<mi> fac,ifac,invn;
	void check(int x) {
		if (fac.empty()) {
			fac={mi(1),mi(1)};
			ifac={mi(1),mi(1)};
			invn={mi(0),mi(1)};
		}
		while (SZ(fac)<=x) {
			int n=SZ(fac),m=SZ(fac)*2;
			fac.resize(m);
			ifac.resize(m);
			invn.resize(m);
			for (int i=n;i<m;i++) {
				fac[i]=fac[i-1]*mi(i);
				invn[i]=mi(MOD-MOD/i)*invn[MOD%i];
				ifac[i]=ifac[i-1]*invn[i];
			}
		}
	}
	mi gfac(int x) {
		check(x); return fac[x];
	}
	mi ginv(int x) {
		check(x); return invn[x];
	}
	mi gifac(int x) {
		check(x); return ifac[x];
	}
	mi binom(int n,int m) {
		if (m < 0 || m > n) return mi(0);
		return gfac(n)*gifac(m)*gifac(n - m);
	}
}

const int N=101000;
VI e[N];
int par[N],c0[N],cm[N],d0[N],dm[N],a[N],b[N];
int a0,am,b0,bm,n,m1,m2;
char s1[N],s2[N];
mi ans;
void dfs0(int u,int f) {
	for (auto v:e[u]) if (v!=f) {
		par[v]=par[u]^1;
		dfs0(v,u);
	}
}
vector<PII> ps;

const int B=400;
struct ds {
	int m1,m2;
	int X,Y;
	mi pre[N/B+10][N/B+10];
	mi prey[N],prex[N],prexy[N*2];
	void init(int _m1,int _m2) {
		m1=_m1;
		m2=_m2;
		X=m2;
		Y=m1-m2;
		if (X>=0&&Y>=0) {
			rep(y,0,Y+1) prey[y]=simp::gifac(y)*simp::gifac(Y-y);
			rep(x,0,X+1) prex[x]=simp::gifac(x)*simp::gifac(X-x);
			rep(xy,0,X+Y) prexy[xy]=simp::gfac(xy)*simp::gfac(X+Y-1-xy);
			for (int x0=0;x0<=X;x0+=B) {
				mi c0=way(0,0,X,Y);
				pre[x0/B][0]=c0;
				for (int y0=1;y0<=Y;y0++) {
					c0-=way(0,0,x0,y0-1)*way(x0+1,y0-1,X,Y);
					if (y0%B==0) pre[x0/B][y0/B]=c0;
				}
			}
		}
	}
	mi way(int x1,int y1,int x2,int y2) {
		return simp::binom(x2+y2-x1-y1,x2-x1);
	}
	mi query(int p1,int q1) {
		if (X<0||Y<0) return 0;
		int x0=q1,y0=p1-q1;
		if (x0>=X||y0<=0) return way(0,0,X,Y);
		if (x0<0||y0>Y) return 0;
		mi ans=pre[x0/B][y0/B];
		int x1=x0/B*B,y1=y0/B*B;
		mi w1=0;
		if (x1<X) {
			for (int y=y1;y<y0;y++) w1+=prexy[x1+y]*prey[y];
			w1*=simp::gifac(x1)*simp::gifac(X-x1-1);
			ans-=w1;
		}
		if (y0>0) {
			mi w2=0;
			for (int x=x1+1;x<=x0;x++) w2+=prexy[x+y0-1]*prex[x];
			ans+=w2*simp::gifac(y0-1)*simp::gifac(Y-y0);
		}
		return ans;
	}
}r1,r2;
void dfs(int u,int f) {
	c0[u]=a[u]==0,cm[u]=a[u]==-1;
	d0[u]=b[u]==0,dm[u]=b[u]==-1;
	for (auto v:e[u]) if (v!=f) {
		dfs(v,u);
		c0[u]+=c0[v];
		cm[u]+=cm[v];
		d0[u]+=d0[v];
		dm[u]+=dm[v];
	}
	int p1=cm[u]+dm[u];
	int q1=d0[u]+dm[u]-c0[u];
	ans+=p1*simp::binom(m1-1,m2-1)-q1*simp::binom(m1,m2);
	if (q1>0) {
		ans-=2*p1*r1.query(p1-1,q1-1);
		ans+=2*q1*r2.query(p1,q1);
	}
}
void solve() {
	scanf("%d",&n);
	rep(i,1,n+1) e[i].clear();
	rep(i,1,n) {
		int u,v;
		scanf("%d%d",&u,&v);
		e[u].pb(v);
		e[v].pb(u);
	}
	dfs0(1,0);
	scanf("%s",s1+1);
	rep(i,1,n+1) {
		a[i]=s1[i]=='?'?-1:(s1[i]-'0');
		if (a[i]!=-1) a[i]^=par[i];
	}
	scanf("%s",s2+1);
	rep(i,1,n+1) {
		b[i]=s2[i]=='?'?-1:(s2[i]-'0');
		if (b[i]!=-1) b[i]^=par[i];
	}
	a0=0,am=0;
	b0=0,bm=0;
	rep(i,1,n+1) {
		a0+=(a[i]==0),am+=(a[i]==-1);
		b0+=(b[i]==0),bm+=(b[i]==-1);
	}
	m1=am+bm;
	m2=b0+bm-a0;
	r1.init(m1-1,m2-1);
	r2.init(m1,m2);
	ans=0;
	dfs(1,0);
	printf("%d\n",(int)ans);
}

mi calc(int p1,int q1) {
	mi ans=0;
	ans+=p1*simp::binom(m1-1,m2-1)-q1*simp::binom(m1,m2);
	rep(det,0,q1+1) ans-=2*p1*simp::binom(p1-1,det-1)*simp::binom(m1-p1,m2-det);
	rep(det,0,q1+1) ans+=2*q1*simp::binom(p1,det)*simp::binom(m1-p1,m2-det);
	return ans;
}

int _;
int main() {
	for (scanf("%d",&_);_;_--) {
		solve();
	}
}