发现操作是可逆的，如果起始状态和终止状态都能走到同一个状态，那就能组合出一组解。
以任意一节点为根，考虑贪心地确定每个人最后的位置，使他对答案影响最小。策略是将可以放的人放到深度最大的点，然后删掉该点相邻的点，反复去做。
大多数情况下，总有一种方式使得一个节点能走到当前选择的深度最大点，但是有唯一一种情况不行——存在两个儿子上有人，互相卡住对方。此时，可以证明，如果将所有的点都往当前点的反方向能走一步就走一步，如果有解就一定能消除这样的情况。
#include <bits/stdc++.h>
using namespace std;
namespace FastIO {
struct IO {
char ibuf[(1 << 20) + 1], *iS, *iT, obuf[(1 << 20) + 1], *oS;
IO() : iS(ibuf), iT(ibuf), oS(obuf) {} ~IO() { fwrite(obuf, 1, oS - obuf, stdout); }
#if ONLINE_JUDGE
#define gh() (iS == iT ? iT = (iS = ibuf) + fread(ibuf, 1, (1 << 20) + 1, stdin), (iS == iT ? EOF : *iS++) : *iS++)
#else
#define gh() getchar()
#endif
inline bool eof (const char &ch) { return ch == ' ' || ch == '\n' || ch == '\r' || ch == 't' || ch == EOF; }
inline long long read() {
char ch = gh();
long long x = 0;
bool t = 0;
while (ch < '0' || ch > '9') t |= ch == '-', ch = gh();
while (ch >= '0' && ch <= '9') x = (x << 1) + (x << 3) + (ch ^ 48), ch = gh();
return t ? ~(x - 1) : x;
}
inline void read (char *s) {
char ch = gh(); int l = 0;
while (eof(ch)) ch = gh();
while (!eof(ch)) s[l++] = ch, ch = gh();
}
inline void read (double &x) {
char ch = gh(); bool t = 0;
while (ch < '0' || ch > '9') t |= ch == '-', ch = gh();
while (ch >= '0' && ch <= '9') x = x * 10 + (ch ^ 48), ch = gh();
if (ch != '.') return t && (x = -x), void(); ch = gh();
for (double cf = 0.1; '0' <= ch && ch <= '9'; ch = gh(), cf *= 0.1) x += cf * (ch ^ 48);
t && (x = -x);
}
inline void pc (char ch) {
#ifdef ONLINE_JUDGE
if (oS == obuf + (1 << 20) + 1) fwrite(obuf, 1, oS - obuf, stdout), oS = obuf;
*oS++ = ch;
#else
putchar(ch);
#endif
}
template<typename _Tp>
inline void write (_Tp x) {
static char stk[64], *tp = stk;
if (x < 0) x = ~(x - 1), pc('-');
do *tp++ = x % 10, x /= 10;
while (x);
while (tp != stk) pc((*--tp) | 48);
}
inline void write (char *s) {
int n = strlen(s);
for (int i = 0; i < n; i++) pc(s[i]);
}
} io;
inline long long read () { return io.read(); }
template<typename Tp>
inline void read (Tp &x) { io.read(x); }
template<typename _Tp>
inline void write (_Tp x) { io.write(x); }
}
using namespace FastIO;
const int maxn=1e5+10;
int n,k,a[maxn],b[maxn],tz1[maxn],tz2[maxn],dep[maxn],p[maxn],ct[maxn];
vector<int> G[maxn];
vector< pair<int,int> > SA,SB;
void predfs(int u,int fa)
{
dep[u]=dep[fa]+1;
for(int v:G[u])
if(v!=fa)
predfs(v,u);
}
bool spindfs(int u,int fa,int *d,int *c,vector< pair<int,int> > &A)
{
int flag=0,cm=0,cnt=0;
for(int v:G[u])
if(v!=fa)
{
if(d[v]&&c[v])flag=1;
if(d[v]&&!c[v])cm=v,cnt++;
}
if(flag)return 0;
if(cnt==1)
{
A.emplace_back(cm,u);
//rintf("@%d %d\n",cm,u);
swap(d[u],d[cm]);
return 1;
}
if(!cnt)
{
for(int v:G[u])
if(v!=fa&&spindfs(v,u,d,c,A))
{
// printf("#%d %d\n",v,u);
A.emplace_back(v,u);
swap(d[v],d[u]);
return 1;
}
}
return 0;
}//将任意节点旋到深度最大的点
int levdfs(int u,int fa,int *d,int *c,vector< pair<int,int> > &A)
{
if(d[u])
{
if(c[u])return 0;
for(int v:G[u])
if(v!=fa&&levdfs(v,u,d,c,A)>=2)
{
// printf("?%d %d\n",u,v);
A.emplace_back(u,v);
swap(d[u],d[v]);
return 1;
}
return 0;
}
else
{
int mn=1e9;
for(int v:G[u])
if(v!=fa)
mn=min(mn,levdfs(v,u,d,c,A)+1);
return mn;
}
}//将卡住路径的节点拉远
void solve()
{
n=read();
SA.clear();SB.clear();
for(int i=1;i<=n;i++)G[i].clear(),tz1[i]=tz2[i]=ct[i]=0;
for(int i=1,u,v;i<n;i++)
{
u=read(),v=read();
G[u].push_back(v);
G[v].push_back(u);
}
k=read();
for(int i=1;i<=k;i++)
a[i]=read(),tz1[a[i]]=1;
for(int i=1;i<=k;i++)
b[i]=read(),tz2[b[i]]=1;
predfs(1,0);for(int i=1;i<=n;i++)p[i]=i;sort(p+1,p+1+n,[&](int a,int b){return dep[a]>dep[b];});
for(int i=1;i<=n;i++)
{
int u=p[i];
if(!tz1[u])levdfs(u,0,tz1,ct,SA),spindfs(u,0,tz1,ct,SA);
if(!tz2[u])levdfs(u,0,tz2,ct,SB),spindfs(u,0,tz2,ct,SB);
ct[u]=1;
}
for(int i=1;i<=n;i++)if(tz1[i]!=tz2[i])
{
puts("NO");
return;
}
puts("YES");
printf("%d\n",SA.size()+SB.size());
for(auto [u,v]:SA)printf("%d %d\n",u,v);
reverse(SB.begin(),SB.end());
for(auto [u,v]:SB)printf("%d %d\n",v,u);
return;
}
int main()
{
int T;
scanf("%d\n",&T);
while(T--)solve();
return 0;
}