#include <bits/stdc++.h>

using namespace std;

// #define int long long
// #define x first
// #define y second
#define File(a) freopen(a".in", "r", stdin), freopen(a".out", "w", stdout)

inline void debug() { cerr << '\n'; }
template<typename Type, typename... Other>
inline void debug(const Type& x, const Other&... y) { cerr << x << ' '; debug(y...); }
#define DEBUG(a...) cerr << "[" << #a << "] = ", debug(a);

typedef long long LL;
typedef pair<int, int> PII;

const int N = 110;
const int INF = 0x3f3f3f3f;

template<typename Type>
inline void read(Type &res)
{
    res = 0;
    int ch = getchar(), flag = 0;
    while (!isdigit(ch)) flag |= ch == '-', ch = getchar();
    while (isdigit(ch)) res = (res << 3) + (res << 1) + (ch ^ 48), ch = getchar();
    res = flag ? -res : res;
}
template<typename Type, typename... Other>
inline void read(Type &res, Other&... y) { read(res), read(y...); }

int n, m, minn = INF;
int h[N], e[N << 1], ne[N << 1], idx;
int depth[N], fa[N][10], tag[N];
array<int, 2> edge[N];
vector<int> ans;

inline void add(int a, int b) { e[++ idx] = b, ne[idx] = h[a], h[a] = idx; }

void dfs(int ver, int pre)
{
    depth[ver] = depth[pre] + 1, fa[ver][0] = pre;
    for (int k = 1; k < 10; k ++)
        fa[ver][k] = fa[fa[ver][k - 1]][k - 1];
    for (int i = h[ver]; ~i; i = ne[i])
    {
        int to = e[i];
        if (to == pre) continue;
        dfs(to, ver);
    }
}

int LCA(int a, int b)
{
    if (depth[a] < depth[b]) swap(a, b);
    for (int k = 9; ~k; k --)
        if (depth[fa[a][k]] >= depth[b]) a = fa[a][k];
    if (a == b) return a;
    for (int k = 9; ~k; k --)
        if (fa[a][k] != fa[b][k]) a = fa[a][k], b = fa[b][k];
    return fa[a][0];
}

signed main()
{
    memset(h, -1, sizeof h), idx = -1;
    read(n);
    for (int i = 1; i < n; i ++)
    {
        int a, b; read(a, b);
        add(a, b), add(b, a);
    }

    read(m);
    for (int i = 1; i <= m; i ++)
        read(edge[i][0], edge[i][1]);
    dfs(1, 0);

    for (int state = 0; state < 1 << n; state ++)
    {
        memset(tag, 0, sizeof tag);
        for (int ver = 0; ver < n; ver ++)
            if (state >> ver & 1) tag[ver + 1] = true;

        bool flag = true;
        for (int i = 1; i <= m; i ++)
        {
            int lca = LCA(edge[i][0], edge[i][1]);
            if (tag[lca]) continue;
            bool ok = false;
            for (int cur = edge[i][0]; cur != lca; cur = fa[cur][0])
                if (tag[cur])
                {
                    ok = true;
                    break;
                }
            if (ok) continue;
            for (int cur = edge[i][1]; cur != lca; cur = fa[cur][0])
                if (tag[cur])
                {
                    ok = true;
                    break;
                }
            if (!ok)
            {
                flag = false;
                break;
            }
        }
        if (flag)
        {
            if (minn > __builtin_popcount(state))
            {
                minn = __builtin_popcount(state);
                ans.clear();
                for (int ver = 1; ver <= n; ver ++)
                    if (tag[ver]) ans.push_back(ver); 
            }
        }
    }

    cout << minn << '\n';
    for (int ver : ans) cout << ver << ' ';
    cout << '\n';

    return 0;
}