#include <bits/stdc++.h>

struct Edge {
    int u, v;
};

struct EdgeSet {
    std::set<std::pair<int, int>> s;
    void insert(int u, int v) {
        if (u > v) std::swap(u, v);
        s.emplace(u, v);
    }
    bool contains(int u, int v) {
        if (u > v) std::swap(u, v);
        return s.find({u, v}) != s.end();
    }
};

struct DSU {
    std::vector<int> fa;
    explicit DSU(int n) : fa(n) {
        std::iota(fa.begin(), fa.end(), 0);
    }
    int find(int node) {
        return fa[node] == node ? node : fa[node] = find(fa[node]);
    }
    void merge(int x, int y) {
        x = find(x);
        y = find(y);
        fa[x] = y;
    }
};

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n;
    std::cin >> n;

    std::vector<Edge> edge(n - 1);
    for (auto &[u, v] : edge) {
        std::cin >> u >> v;
        --u, --v;
    }

    std::vector<std::vector<int>> adj(n);
    for (auto [u, v] : edge) {
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    std::vector<uint8_t> c(n);
    std::vector<int> dep(n);
    auto dfs = [&](auto &self, int node, int p, int v) -> void {
        c[node] = v;
        for (int to : adj[node]) {
            if (to == p) continue;
            dep[to] = dep[node] + 1;
            self(self, to, node, v);
        }
    };

    auto [U, V] = edge.back();
    dfs(dfs, U, V, 0);
    dfs(dfs, V, U, 1);

    std::vector<Edge> ans;
    for (int i = 0; i < n - 2; ++i) {
        auto [u, v] = edge[i];
        if (dep[u] < dep[v]) std::swap(u, v);

        ans.push_back(Edge{u, c[u] == 0 ? V : U});
    }

    EdgeSet es;
    for (auto [u, v] : edge) {
        es.insert(u, v);
    }

    DSU dsu(n);
    for (auto [u, v] : ans) {
        assert(dsu.find(u) != dsu.find(v));
        dsu.merge(u, v);
    }

    for (int x : {U, V}) {
        bool ok = false;
        for (int i = 0; i < n; ++i) {
            if (dsu.find(i) != dsu.find(x) && !es.contains(i, x)) {
                ans.push_back(Edge{i, x});
                ok = true;
                break;
            }
        }
        if (ok) break;
    }

    if (ans.size() != n - 1) {
        std::cout << "-1\n";
    } else {
        for (auto [u, v] : ans) {
            std::cout << u + 1 << ' ' << v + 1 << '\n';
        }
    }
}