#include <bits/stdc++.h>

using namespace std;

#ifdef LOCAL
template<class... T> void dbg(T... x) { char e{}; ((cerr << e << x, e = ' '), ...); }
template<class T> void org(T l, T r) { while (l != r) cerr << ' ' << *l++; cerr << '\n'; }
#define debug(x...) dbg(#x, '=', x, '\n')
#define olist(x...) dbg(#x, '='), org(x)
#else
#define debug(...) ((void)0)
#define olist(...) ((void)0)
#endif
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define ff first
#define ss second

using u32 = unsigned int;
using i64 = long long;
using u64 = unsigned long long;
using i128 = __int128;
using u128 = unsigned __int128;
using Pt = pair<i128, i128>;

template<class T>
inline constexpr T inf = numeric_limits<T>::max() / 2;
constexpr int mod = 998244353;

Pt operator+(Pt a, Pt b) { return {a.ff + b.ff, a.ss + b.ss}; }
Pt operator-(Pt a, Pt b) { return {a.ff - b.ff, a.ss - b.ss}; }
i128 operator^(Pt a, Pt b) { return a.ff * b.ss - a.ss * b.ff; }
i128 cro(Pt a, Pt b, Pt c) { return (b - a) ^ (c - a); }

template<class T> bool chmin(T &a, T b) { return (b < a and (a = b, true)); }
template<class T> bool chmax(T &a, T b) { return (a < b and (a = b, true)); }
template<class... T> int add(T... x) { int t{}; return (((t += x) %= mod), ...), t; }
template<class... T> int mul(T... x) { i64 t{1}; return (((t *= x) %= mod), ...), t; }

void solve() {
    int n;
    cin >> n;

    vector G(n, vector<int>{});
    vector<pair<int, int>> edg(n - 1);
    for (auto &[u, v] : edg) {
        cin >> u >> v;
        u--, v--;
        G[u].push_back(v);
        G[v].push_back(u);
    }

    int A = edg.back().ff;
    int B = edg.back().ss;

    int C = -1;
    vector<int> dep(n);
    vector<int> to(n);
    function<void(int, int)> dfs = [&](int u, int f) {
        if (dep[u] >= 2) {
            if (f != B) C = u;
            to[u] = A;
        }
        if (dep[u] == 1 and u != B) {
            to[u] = B;
        }
        for (int v : G[u]) if (v != f) {
            dep[v] = dep[u] + 1;
            dfs(v, u);
        }
    };
    dfs(A, -1);
    to[B] = C;
    
    if (C == -1) {
        cout << "-1\n";
        return;
    }

    for (auto [u, v] : edg) {
        if (dep[u] < dep[v]) swap(u, v);
        cout << u + 1 << ' ' << to[u] + 1 << '\n';
    }
} 

signed main() {
    cin.tie(0)->sync_with_stdio(false);
    cin.exceptions(cin.failbit);
    int T = 1;
    // cin >> T;
    while (T--) {
        solve();
    }
    
    return 0;
}