OI XXXIII - kon

// https://szkopul.edu.pl/problemset/problem/IdNBiHtkms48GdnUVsFb51Xz/site/?key=statement

#include <bits/stdc++.h>

// #define GARY_DBG
#define GARY_LIB

constexpr int sizik = 1000 * 1001, sizik2 = 22;

#define ar std::array

typedef std::vector<std::vector<int>> _kra;
int n, q;

int up[sizik][sizik2];

std::vector<int> kra[sizik];

int pre[sizik], post[sizik], timer;
int depth[sizik];

void DFS(int v, int p, int d) {
    depth[v] = d;
    pre[v] = ++timer;
    up[v][0] = p;
    for (int i = 1; i < sizik2; i++) {
        up[v][i] = up[up[v][i - 1]][i - 1];
    }
    for (const auto& u : kra[v]) {
        if (u == p) continue;
        DFS(u, v, d + 1);
    }
    post[v] = ++timer;
}

bool is_ancestor(int v, int u) {
    return pre[v] <= pre[u] && post[u] <= post[v];
}

int lca(int a, int b) {
    if (is_ancestor(a, b)) return a;
    if (is_ancestor(b, a)) return b;
    for (int i = sizik2 - 1; i >= 0; i--) {
        if (!is_ancestor(up[a][i], b)) {
            a = up[a][i];
        }
    }
    return up[a][0];
}

namespace seg_tree {

int d[8 * sizik];

int query(int v, int tl, int tr, int l, int r) {
    if (l > r) return 0;
    if (l == tl && r == tr) return d[v];
    int tm = (tl + tr) / 2;
    return query(2 * v, tl, tm, l, std::min(r, tm)) + query(2 * v + 1, tm + 1, tr, std::max(l, tm + 1), r);
}

void update(int v, int tl, int tr, int x, int a) {
    if (tl == tr) {
        d[v] = a;
    } else {
        int tm = (tl + tr) / 2;
        if (x <= tm) {
            update(2 * v, tl, tm, x, a);
        } else {
            update(2 * v + 1, tm + 1, tr, x, a);
        }

        d[v] = d[2 * v] + d[2 * v + 1];
    }
}

} // namespace seg_tree

void solve() {
    std::cin >> n >> q;

    for (int i = 0; i < n - 1; i++) {
        int a, b;
        std::cin >> a >> b;

        kra[a].push_back(b);
        kra[b].push_back(a);
    }

    DFS(1, 1, 1);

    std::vector<ar<int, 3>> v(q);
    for (int i = 0; i < q; i++) {
        int a, b;
        std::cin >> a >> b;

        if (pre[a] > pre[b]) std::swap(a, b);
        v[i] = {a, b, lca(a, b)};
    }

    std::sort(v.begin(), v.end(), [](const auto& a, const auto& b) { return depth[a[2]] > depth[b[2]]; });

    std::vector<int> ans;
    for (const auto& [a, b, c] : v) {
        assert(pre[a] < pre[b]);
        int A = seg_tree::query(1, 1, 2 * n, pre[c], pre[a]);
        int B = seg_tree::query(1, 1, 2 * n, pre[c], pre[b]);
        if (A == 0 && B == 0) {
            ans.push_back(c);
            seg_tree::update(1, 1, 2 * n, pre[c], 1);
            seg_tree::update(1, 1, 2 * n, post[c], -1);
        }
    }

    std::cout << ans.size() << '\n';
    for (const auto& a : ans) {
        std::cout << a << ' ';
    }
    std::cout << '\n';
}

int32_t main() {
#ifndef GARY_DBG
    std::ios_base::sync_with_stdio(0);
    std::cin.tie(0);
    std::cout.tie(0);
#endif

    int t = 1;
    // std::cin >> t;

    for (; t > 0; t--) {
        solve();
    }

    return 0;
}