// jiangly's method
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <set>
#include <utility>
#include <vector>
#include <cassert>
using namespace std;

namespace solve
{
    const int maxn = 2010;
    typedef pair<int, int> pii;

    struct work
    {
        vector<vector<int>> e;
        vector<pii> ans;
        int now[maxn], dep[maxn], used[maxn], father[maxn];
        void move(int x, int y)
        {
            assert(now[x]);
            assert(!now[y]);
            ans.push_back({x, y}), now[x] = 0, now[y] = 1;
        }
        void dfs1(int x, int fa)
        {
            father[x] = fa;
            for (int v : e[x])
                if (v != fa)
                    dep[v] = dep[x] + 1, dfs1(v, x);
        }
        int can_move(int x, int fa)
        {
            if (now[x])
                return 0;
            int res = 0;
            for (int v : e[x])
                if (v != fa)
                    res |= now[v];
            return res == 0;
        }
        void try_move(int x, int fa)
        {
            for (int v : e[x])
                if (v != fa && !used[v])
                {
                    try_move(v, x);
                    if (can_move(v, x))
                    {
                        if (now[x])
                        {
                            move(x, v);
                            return;
                        }
                    }
                }
        }
        int dfs2(int x, int fa)
        {
            vector<int> is;
            for (int v : e[x])
                if (v != fa && !used[v] && now[v])
                    is.push_back(v);
            // cerr << x << " " << fa << " " << is.size() << endl;
            if (is.size() == 0)
            {
                for (int v : e[x])
                    if (v != fa && !used[v])
                    {
                        int flag = dfs2(v, x);
                        if (flag)
                        {
                            assert(now[v]);
                            move(v, x);
                            return 1;
                        }
                    }
            }
            else if (is.size() == 1)
            {
                int v = is.front();
                assert(now[v]);
                move(v, x);
                return 1;
            }
            else
            {
                int son = -1;
                for (int v : is)
                {
                    if (v == is.back() && son == -1)
                    {
                        son = v;
                        break;
                    }
                    try_move(v, x);
                    if (now[v])
                    {
                        if (son == -1)
                            son = v;
                        else
                            return 0;
                    }
                }
                move(son, x);
                return 1;
            }
            return 0;
        }
        vector<pii> solve(int n, const vector<vector<int>> &edge_, const vector<int> &now_)
        {
            // cerr << "begin" << endl;
            e = edge_;
            for (int i = 1; i <= n; i++)
                now[i] = now_[i];
            ans.clear();

            dfs1(1, 0);
            vector<pii> tmp;
            for (int i = 1; i <= n; i++)
                tmp.push_back({dep[i], i});
            sort(tmp.begin(), tmp.end(), greater<pii>());
            for (auto o : tmp)
            {
                int x = o.second;
                // cerr << x << endl;
                if (!used[x] && !now[x])
                    dfs2(x, -1);               
                if (now[x])
                    for (int v : e[x])
                        used[v] = 1;    
                // for (int i = 1; i <= n; i++)
                    // cerr << now[i] << " ";
                // cerr << endl;
            }
            for (int i = 1; i <= n; i++)
                dep[i] = used[i] = father[i] = 0;
            // cerr << "end" << endl;
            return ans;
        }
    } S, T;

    int check(int n)
    {
        for (int i = 1; i <= n; i++)
            if (S.now[i] != T.now[i])
                return 0;
        return 1;
    }

    void main()
    {
        int n;
        cin >> n;
        vector<vector<int>> e(n + 1);
        for (int i = 1, x, y; i < n; i++)
            cin >> x >> y, e[x].push_back(y), e[y].push_back(x);
        int k;
        cin >> k;
        vector<int> a(n + 1), b(n + 1);
        for (int i = 1, x; i <= k; i++)
           cin >> x, a[x] = 1; 
        for (int i = 1, x; i <= k; i++)
           cin >> x, b[x] = 1; 
        auto res1 = S.solve(n, e, a), res2 = T.solve(n, e, b);
        if (!check(n))
        {
            cout << "NO\n";
            return;
        }
        cout << "YES" << '\n';
        cout << res1.size() + res2.size() << '\n';
        reverse(res2.begin(), res2.end());
        for (auto p : res1)
            cout << p.first << " " << p.second << '\n';
        for (auto p : res2)
            cout << p.second << " " << p.first << '\n';
    }
}

int main()
{
    ios::sync_with_stdio(false);
    int T;
    cin >> T;
    while (T--)
        solve::main();
}