#include<bits/stdc++.h>
using namespace std;

const int N=4e5+1e3+7;

namespace LCT{
    int c[N][2],fa[N];
    bool rev[N];
    int key[N],val[N];
    bool isroot(int x)
    {
        return c[fa[x]][0]!=x&&c[fa[x]][1]!=x;
    }
    bool type(int x)
    {
        return c[fa[x]][1]==x;
    }
    void update(int x)
    {
        key[x]=max({key[c[x][0]],key[c[x][1]],val[x]});    
    }
    void setrev(int x)
    {
        rev[x]^=1;
        swap(c[x][0],c[x][1]);
    }
    void pushdown(int x)
    {
        if(rev[x])
        {
            setrev(c[x][0]);
            setrev(c[x][1]);
            rev[x]=0;
        }
    }
    void rotate(int x)
    {
        int y=fa[x],d=type(x);
        fa[x]=fa[y];
        if(!isroot(y))
            c[fa[y]][type(y)]=x;
        fa[c[x][!d]]=y,c[y][d]=c[x][!d];
        c[x][!d]=y,fa[y]=x;
        update(y);
    }
    void splay(int x)
    {
        stack<int> sta;
        sta.push(x);
        int t=x;while(!isroot(t))sta.push(t=fa[t]);
        while(!sta.empty())pushdown(sta.top()),sta.pop();
        for(int i=fa[x];!isroot(x);rotate(x),i=fa[x])
        {
            if(!isroot(i))
                rotate(type(i)==type(x)?i:x);
        }
        update(x);
    }
    void access(int x)
    {
        for(int t=0;x;t=x,x=fa[x])
        {
            splay(x);
            c[x][1]=t;
            update(x);
        }
    }
    void makeroot(int x)
    {
        access(x);
        splay(x);
        setrev(x);
    }
    void link(int x,int y)
    {
        makeroot(x);
        fa[x]=y;
    }
    void cut(int x,int y)
    {
        makeroot(x);
        access(y);
        access(x);
        fa[y]=0;
    }
}

int n;

vector<int> g[N];

int U[N],V[N];

vector<pair<int,int> >E;

int fa[N];

int find(int x)
{
    return x==fa[x]?x:fa[x]=find(fa[x]);
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin>>n;
    for(int i=1;i<n;i++)
    {
        int u,v;
        cin>>u>>v;
        g[u].push_back(v);
        g[v].push_back(u);
        U[i]=u,V[i]=v;
    }
    queue<int> q;
    q.push(1);
    for(int i=1;i<=n;i++)
        fa[i]=i;
    fa[n+1]=n+1;
    fa[1]=2;
    while(!q.empty())
    {
        int x=q.front();
        q.pop();
        sort(g[x].begin(),g[x].end());
        int la=1;
        for(auto v:g[x])
        {
            for(int i=find(la);i<v;i=find(i))
            {
                E.push_back({x,i});
                fa[i]=i+1;
                q.push(i);
            }
            la=v+1;
        }
        for(int i=find(la);i<=n;i=find(i))
        {
            E.push_back({x,i});
            fa[i]=i+1;
            q.push(i);
        }
    }
    if(E.size()!=n-1)
    {
        cout<<"-1\n";
        return 0;
    }
    int cn=n;
    using namespace LCT;
    for(auto [x,y]:E)
    {
        ++cn;
        val[cn]=key[cn]=cn;
        link(x,cn);
        link(cn,y);
    }
    vector<pair<int,int> >ans;
    for(int i=n-1;i>=1;i--)
    {
        int x=U[i],y=V[i];
        makeroot(x),access(y),splay(y);
        int e=key[y]-n-1;
        ans.push_back(E[e]);
        cut(E[e].first,e+n+1);
        cut(E[e].second,e+n+1);
        link(x,y);
    }
    reverse(ans.begin(),ans.end());
    for(auto [x,y]:ans)
        cout<<x<<" "<<y<<"\n";  
}