#include <bits/stdc++.h>

using i64 = long long;
using u64 = unsigned long long;
using u32 = unsigned;
using u128 = unsigned __int128;

std::array<int, 2> E(int u, int v) {
    if (u > v) {
        std::swap(u, v);
    }
    return {u, v};
}

std::pair<std::vector<std::array<int, 2>>, std::vector<std::array<int, 2>>> solve(int N, std::vector<std::array<int, 2>> e1, std::vector<std::array<int, 2>> e2) {
    if (e1.empty()) {
        return {};
    }
    std::vector<std::vector<int>> T1(N), T2(N);
    for (auto [u, v] : e1) {
        T1[u].push_back(v);
        T1[v].push_back(u);
    }
    for (auto [u, v] : e2) {
        T2[u].push_back(v);
        T2[v].push_back(u);
    }
    
    bool swapped = false;
    std::vector<std::array<int, 2>> a, b;
    for (int x = 0; x < N; x++) {
        if (T1[x].size() + T2[x].size() == 2) {
            int y = T1[x][0];
            int z = T2[x][0];
            e1.erase(std::find(e1.begin(), e1.end(), E(x, y)));
            e2.erase(std::find(e2.begin(), e2.end(), E(x, z)));
            std::tie(a, b) = solve(N, e1, e2);
            a.push_back(E(x, y));
            b.push_back(E(x, z));
            break;
        } else if (T1[x].size() + T2[x].size() == 3) {
            if (T1[x].size() == 2) {
                std::swap(T1, T2);
                std::swap(e1, e2);
                swapped = true;
            }
            int w = T1[x][0];
            int y = T2[x][0];
            int z = T2[x][1];
            e1.erase(std::find(e1.begin(), e1.end(), E(x, w)));
            e2.erase(std::find(e2.begin(), e2.end(), E(x, y)));
            e2.erase(std::find(e2.begin(), e2.end(), E(x, z)));
            e2.push_back(E(y, z));
            std::tie(a, b) = solve(N, e1, e2);
            
            int k = std::find(b.begin(), b.end(), E(y, z)) - b.begin();
            auto [u, v] = a[k];
            
            std::vector<std::vector<int>> T(N);
            for (int i = 0; i < a.size(); i++) {
                if (i != k) {
                    auto [u, v] = a[i];
                    T[u].push_back(v);
                    T[v].push_back(u);
                }
            }
            
            std::vector<bool> vis(N);
            auto dfs = [&](auto &&self, int x, int p) -> void {
                vis[x] = true;
                for (auto y : T[x]) {
                    if (y == p) {
                        continue;
                    }
                    self(self, y, x);
                }
            };
            dfs(dfs, u, -1);
            
            if (vis[w] == vis[y]) {
                b[k] = E(x, z);
                a.insert(a.begin() + k + 1, E(x, w));
                b.insert(b.begin() + k + 1, E(x, y));
            } else {
                b[k] = E(x, y);
                a.insert(a.begin() + k + 1, E(x, w));
                b.insert(b.begin() + k + 1, E(x, z));
            }
            break;
        }
    }
    
    if (swapped) {
        std::swap(a, b);
    }
    return {a, b};
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int N;
    std::cin >> N;
    
    std::vector<std::array<int, 2>> e1(N - 1), e2(N - 1);
    for (int i = 0; i < N - 1; i++) {
        int u, v;
        std::cin >> u >> v;
        u--;
        v--;
        e1[i] = E(u, v);
    }
    for (int i = 0; i < N - 1; i++) {
        int u, v;
        std::cin >> u >> v;
        u--;
        v--;
        e2[i] = E(u, v);
    }
    
    auto [a, b] = solve(N, e1, e2);
    
    for (int i = 0; i < N - 1; i++) {
        std::cout << std::find(e1.begin(), e1.end(), a[i]) - e1.begin() + 1 << " \n"[i == N - 2];
    }
    for (int i = 0; i < N - 1; i++) {
        std::cout << std::find(e2.begin(), e2.end(), b[i]) - e2.begin() + 1 << " \n"[i == N - 2];
    }
    
    return 0;
}