#include <set>
#include <array>
#include <queue>
#include <string>
#include <vector>
#include <cassert>
#include <iostream>
#include <algorithm>
using namespace std;

string to_string(const vector<int>& arr) {
    string res = "[";
    for (int i = 0; i < int(arr.size()); i++) {
        if (i != 0) {
            res += ", ";
        }
        res += to_string(arr[i]);
    }
    res += "]";
    return res;
}

pair<int, vector<int> > component(int N, const vector<vector<int> >& G) {
    vector<int> res(N, -1);
    int rank = 0;
    auto dfs = [&](auto& self, int x) -> void {
        res[x] = rank;
        for (int i : G[x]) {
            if (res[i] == -1) {
                self(self, i);
            }
        }
    };
    for (int i = 0; i < N; i++) {
        if (res[i] == -1) {
            dfs(dfs, i);
            rank++;
        }
    }
    return {rank, res};
}

pair<vector<int>, vector<int> > solve_connected(int N, const vector<vector<int> >& G) {
    int root = -1;
    for (int i = 0; i < N; i++) {
        if (G[i].size() >= 3) {
            root = i;
            break;
        }
    }
    vector<bool> adj(N, false);
    set<pair<int, int> > tree;
    auto add_edge = [&](int a, int b) {
        if (a > b) {
            swap(a, b);
        }
        tree.insert({a, b});
    };
    for (int i = 1; i < G[root].size(); i++) {
        adj[G[root][i]] = true;
        add_edge(root, G[root][i]);
    }
    vector<bool> vis(N, false);
    vector<int> d(N, 1), p(N, root);
    p[root] = -1;
    d[root] = 0;
    auto dfs = [&](auto& self, int x) -> void {
        vis[x] = true;
        for (int i : G[x]) {
            if (!adj[i]) {
                if (!vis[i]) {
                    add_edge(x, i);
                    d[i] = d[x] + 1;
                    p[i] = x;
                    self(self, i);
                }
            }
        }
    };
    dfs(dfs, root);
    vector<array<int, 3> > edges;
    for (int i = 0; i < N; i++) {
        for (int j : G[i]) {
            if (i < j && tree.find({i, j}) == tree.end()) {
                int dist = (!adj[i] && !adj[j] ? d[j] - d[i] : d[j] + d[i]);
                edges.push_back({dist, i, j});
            }
        }
    }
    sort(edges.begin(), edges.end());
    pair<int, int> u1 = {-1, -1}, u2 = {-1, -1};
    for (int i = 1; i < edges.size(); i++) {
        if (edges[i - 1][0] == edges[i][0]) {
            u1 = {edges[i - 1][1], edges[i - 1][2]};
            u2 = {edges[i][1], edges[i][2]};
            break;
        }
    }
    auto get_path = [&](int x, int y) -> vector<int> {
        vector<int> xv, yv;
        while (x != y) {
            if (d[x] >= d[y]) {
                xv.push_back(x);
                x = p[x];
            } else {
                yv.push_back(y);
                y = p[y];
            }
        }
        xv.push_back(x);
        reverse(yv.begin(), yv.end());
        xv.insert(xv.end(), yv.begin(), yv.end());
        return xv;
    };
    return {get_path(u1.first, u1.second), get_path(u2.first, u2.second)};
}

pair<vector<int>, vector<int> > solve(int N, const vector<vector<int> >& G) {
    // step #1. consider components
    auto [Z, comp] = component(N, G);
    vector<int> verts(Z), edges(Z);
    for (int i = 0; i < N; i++) {
        verts[comp[i]]++;
        edges[comp[i]] += G[i].size();
    }
    for (int i = 0; i < Z; i++) {
        edges[i] /= 2;
    }
    int id = -1;
    for (int i = 0; i < Z; i++) {
        if (verts[i] >= 4 && edges[i] >= 2 * verts[i] - 3) {
            id = i;
            break;
        }
    }
    assert(id != -1);

    // step #2. reduction
    vector<int> idx(N, -1), revidx;
    int cnt = 0;
    for (int i = 0; i < N; i++) {
        if (comp[i] == id) {
            idx[i] = cnt++;
            revidx.push_back(i);
        }
    }
    vector<vector<int> > H(verts[id]);
    for (int i = 0; i < N; i++) {
        if (comp[i] == id) {
            for (int j : G[i]) {
                H[idx[i]].push_back(idx[j]);
            }
        }
    }
    pair<vector<int>, vector<int> > res = solve_connected(verts[id], H);
    
    // step #3. restoration
    pair<vector<int>, vector<int> > ans = res;
    for (int& i : ans.first) {
        i = revidx[i];
    }
    for (int& i : ans.second) {
        i = revidx[i];
    }

    return ans;
}

int main() {
    // step #1. input
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int N;
    cin >> N;
    vector<vector<int> > G(N);
    for (int i = 0; i < 2 * N - 3; i++) {
        int a, b;
        cin >> a >> b;
        a--; b--;
        G[a].push_back(b);
        G[b].push_back(a);
    }
    pair<vector<int>, vector<int> > ans = solve(N, G);
    int L = ans.first.size();
    cout << L << '\n';
    for (int i = 0; i < L; i++) {
        cout << ans.first[i] + 1 << (i != L - 1 ? ' ' : '\n');
    }
    for (int i = 0; i < L; i++) {
        cout << ans.second[i] + 1 << (i != L - 1 ? ' ' : '\n');
    }
    return 0;
}