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

// Define Template          Python++
// Data Structure and Algorithm
#pragma region
#define all(vec)            (vec).begin(),(vec).end()
#define sortvec(vec)        sort(all(vec));
#define minvec(vec)         *min_element(all(vec))
#define maxvec(vec)         *max_element(all(vec))
#define uma(var,val)        var=max(var,(val));
#define umi(var,val)        var=min(var,(val));
#define sumvec(vec)         accumulate(all(vec),0LL)
#define reversevec(vec)     reverse(all(vec));
#define range(i,s,e)        for(int i=s;i<e;i++)
#define range2(i,s,e)       for(int i=s;i>=e;i--)
#define fors(var,arr)       for(auto &var:arr)
// Input Output Manage
#define debug(x)            cout<<(#x)<<" : "<<(x)<<endl;
#define test                cout<<"test"<<endl;
#define fastIO              ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define floatprecision      cout<<fixed<<setprecision(6);
#define fileread            freopen("input.txt","r",stdin);
#define fileout             freopen("output.txt","w",stdout);
#define query               cin>>QUERY;while(QUERY--)
#define inputvec(vec,am)    vector<int> vec(am);fors(num,vec)cin>>num;
#define inputmat(mat,n,m)   vector<vector<int>> mat(n, vector<int>(m, 0));range(i,0,n)range(j,0,m)cin>>mat[i][j];
#define input(var)          int var;cin>>var;
#define input2(a,b)         int a,b;cin>>a>>b;
#define inputp(var)         pair<int,int> var;cin>>var.first>>var.second;
#define inputs(var)         string var;cin>>var;
#define print(var)          cout<<(var)<<endl;
#define prints(var)         cout<<(var)<<" ";
#define print2(var1,var2)   cout<<(var1)<<" "<<(var2)<<endl;
#define printp(paired)      cout<<(paired.first)<<" "<<(paired.second)<<endl;
#define printyes(cond)      cout<<((cond)?"YES":"NO")<<endl;
#define printarr(arr)       fors(num,arr){cout<<num<<" ";};cout<<endl;
#define endline             cout<<endl;
#pragma endregion
// Macro
#pragma region
#define ll    long long
#define pb    push_back
#define pq    priority_queue
#define mp    make_pair
#define vi    vector<int>
#define pii   pair<int,int>
#define vpii  vector<pii>
#define vvi   vector<vector<int>>
#define mii   map<int,int>
// Oneliner Function
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll sigma(ll num){return num*(num+1)/2;}
ll gcd(ll a, ll b){return (a==0?b:gcd(b%a,a));}
ll lcm(ll a, ll b){return (a*b)/gcd(a,b);}
ll binpow(ll a,ll b,ll m=INT64_MAX){ll r=1;a%=m;while(b){if(b&1)r=(r*a)%m;a=(a*a)%m;b>>=1;}return r;}
ll invmod(ll a,ll m){return gcd(a,m)==1?binpow(a,m-2,m):0;}
ll random(ll l){return rng()%(l+1);}
ll random(ll a,ll b){ll w=b-a;return a+random(w);}
#pragma endregion
// More Macro
#pragma region
#define i32   int32_t
#define int   long long
#define float long double
int QUERY;
#pragma endregion
// Constant
const int MOD = 1e9+7;
const int MOD2 = 998244353;
const long long INF = 1e18;
const int maxn = 1e5+5;

// time DFS process LCA
const int LOG = 20;
vector<int> adj[maxn];
int lift[maxn][LOG];
int par[maxn] = {};
bool vis[maxn] = {};
int depth[maxn] = {};
int starttime[maxn];
int endtime[maxn];
int timer[2*maxn];
int TIME = 0;

void dfs(int node, int prev = 1){
    par[node] = prev;
    vis[node] = 1;
    depth[node] = depth[prev] + 1;
    lift[node][0] = prev;
    timer[node] = TIME;
    starttime[node] = TIME++;
    for(int i=1;i<LOG;i++)
        lift[node][i] = lift[lift[node][i - 1]][i - 1];
    for(auto nxt:adj[node]) {
        if (vis[nxt]) continue;
        dfs(nxt, node);
    }
    timer[node] = TIME;
    endtime[node] = TIME++;
}

bool isancestor(int a, int b){
    return starttime[a] <= starttime[b] && endtime[a] >= endtime[b];
}

int binlift(int a, int k) {
    for (int i=0;i<LOG;i++) {
        if(k & (1 << i)) {
            a = lift[a][i];
        }
    }
    return a;
}

int lca(int a, int b){
    if(isancestor(a, b))return a;
    if(isancestor(b, a))return b;
    for (int i=LOG-1;i>=0;i--) {
        if(!isancestor(lift[a][i], b)) a = lift[a][i];
    }
    return lift[a][0];
}

int dist(int a, int b){ // O(log(n))
    return depth[a] + depth[b] - 2*depth[lca(a,b)];
}


int32_t main() {
    fastIO

    input(n)
    int m = 2 * n - 3;

    vpii edges(m);
    range(i,0,m) {
        input2(u, v)
        adj[u].push_back(v);
        adj[v].push_back(u);

        edges[i] = mp(u, v);
    }

    range(i,1,n + 1) {
        if (!vis[i]) {
            dfs(i, 0);
        }
    }

    vpii back_edges;
    vector<int> radj[n + 1];
    range(i,0,m) {
        pii e = edges[i];
        int d1 = depth[e.first];
        int d2 = depth[e.second];
        if (d1 < d2) {
            swap(e.first, e.second);
        }

        if (par[e.first] != e.second) {
            back_edges.push_back(e);
            radj[e.first].push_back(e.second);
        }
    }

    auto get_back_edge_cycle = [&](pii edge, int point) {
        int v = edge.first;
        int u = edge.second;

        vi path1, path2;
        int _lca = lca(u, v);
        while (u != _lca) {
            path1.push_back(u);
            u = par[u];
        }
        reversevec(path1);

        path2.push_back(v);
        while (v != u) {
            v = par[v];
            path2.push_back(v);
        }

        vi cycle;
        fors(x, path1) {
            cycle.push_back(x);
        }
        fors(x, path2) {
            cycle.push_back(x);
        }

        if (point != 0) {
            cycle.push_back(point);
        }
        
        return cycle;
    };

    vi ans1;
    vi ans2;
    map<int, vector<pair<pii, int>>> cycle_size;
    fors(e, back_edges) {
        int len = dist(e.first, e.second) + 1;
        cycle_size[len].push_back(mp(e, 0));

        if (cycle_size[len].size() == 2) {
            ans1 = get_back_edge_cycle(cycle_size[len][0].first, cycle_size[len][0].second);
            ans2 = get_back_edge_cycle(cycle_size[len][1].first, cycle_size[len][1].second);
        }
        if (!ans1.empty()) {
            break;
        }
    }

    range(i,1,n + 1) {
        int rsz = radj[i].size();
        range(u,0,rsz) {
            range(v,u + 1, rsz) {
                int uu = radj[i][u];
                int vv = radj[i][v];
                int len = dist(uu, vv) + 2;
                cycle_size[len].push_back(mp(mp(uu, vv), i));

                if (cycle_size[len].size() == 2) {
                    ans1 = get_back_edge_cycle(cycle_size[len][0].first, cycle_size[len][0].second);
                    ans2 = get_back_edge_cycle(cycle_size[len][1].first, cycle_size[len][1].second);
                }
                if (!ans1.empty()) {
                    break;
                }
            }
            if (!ans1.empty()) {
                break;
            }
        }
        if (!ans1.empty()) {
            break;
        }
    }

    if (ans1.size() == 0) {
        print(-1)
    } else {
        print(ans1.size())
        printarr(ans1)
        printarr(ans2)
    }
    


    return 0;
}