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

#ifdef DEBUG
#define fast
#else
#define fast cin.tie(0)->sync_with_stdio(0)
#define cerr if(1);else cerr
#define endl '\n'
#endif
#define _ <<' '<<
#define ALL(v) v.begin(),v.end()
#define ft first
#define sd second

using ll = long long;
using ld = long double;
using pii = pair<int,int>;

signed main() {
	fast;
	
	int n;
	cin >> n;
	if (n == 3) {
		cout << -1 << endl;
		return 0;
	}
	
	int m = 2*n-3;
	vector<pii> edge(m);
	vector<vector<int>> G(n);
	for (auto &[u,v]: edge) {
		cin >> u >> v;
		u--; v--;
		G[u].emplace_back(v);
		G[v].emplace_back(u);
	}
	
	vector<int> par(n, -1), dep(n);
	vector<pii> nt{};
	int k = n-2;
	nt.reserve(k);
	function<void(int,int, int)> dfs;
	dfs = [&](int x, int p, int d) {
		par[x] = p;
		dep[x] = d;
		for (auto y: G[x]) if (y != p) {
			if (par[y] == -1) {
				dfs(y, x, d+1);
			} else if (x < y) {
				nt.emplace_back(x, y);
			}
		}
	};
	for (int i = 0; i < n; i++)
		if (par[i] == -1)
			dfs(i, i, 0);
	
	int lgN = __lg(n)+1;
	vector<vector<int>> pars(n,vector<int>(lgN));
	for (int i = 0; i < n; i++)
		pars[i][0] = par[i];
	for (int d = 1; d < lgN; d++)
		for (int i = 0; i < n; i++)
			pars[i][d] = pars[pars[i][d-1]][d-1];
	auto gopar = [&](int x, int w) {
		for (int d = lgN-1; d >= 0; d--)
			if (w >= (1<<d)) x = pars[x][d], w -= (1<<d);
		return x;
	};
	auto lca = [&](int u, int v) {
		if (dep[u] < dep[v]) swap(u, v);
		u = gopar(u, dep[u] - dep[v]);
		if (u == v) return u;
		for (int d = lgN-1; d >= 0; d--)
			if (pars[u][d] != pars[v][d])
				u = pars[u][d], v = pars[v][d];
		return pars[u][0];
	};
	
	auto dist = [&](int u, int v) {
		auto x = lca(u, v);
		return dep[u] + dep[v] - dep[x] * 2;
	};
	
	vector<vector<int>> ans{};
	map<int,vector<int>> mp{};
	for (int i = 0; i < k; i++) {
		auto [u,v] = nt[i];
		auto d = dist(u, v);
		mp[d].emplace_back(i);
	}
	
	auto calc_cycle = [&](int u, int v) {
		vector<int> l{}, r{};
		auto x = lca(u, v);
		for (int t = u; t != x; t = par[t])
			l.emplace_back(t);
		for (int t = v; t != x; t = par[t])
			r.emplace_back(t);
		reverse(ALL(r));
		l.emplace_back(x);
		for (auto y: r)
			l.emplace_back(y);
		return l;
	};
	
	for (const auto& [d,v]: mp) if (v.size() >= 2) {
		for (int i = 0; i < 2; i++) {
			ans.emplace_back( calc_cycle(nt[v[i]].ft, nt[v[i]].sd) );
		}
		break;
	}
	
	if (ans.empty()) {
		vector<int> par2(n, -1), flag(n, -1);
		set<pii> found, snt(ALL(nt));
		function<bool(int,int)> dfs2;
		dfs2 = [&](int x, int p) {
			cerr _ x;
			par2[x] = p;
			flag[x] = flag[p];
			for (auto y: G[x]) if (y != p) {
				if (par2[y] == -1) {
					if (snt.count({ min(x,y), max(x,y) })) continue;
					if (dfs2(y, x)) return true;
				} else if (flag[y] != flag[x]) {
					pii p{ min(x,y), max(x,y) };
					if (snt.count(p)) {
						found.emplace(p);
						if (found.size() >= 2)
							return true;
					}
				}
			}
			return false;
		};
		auto calc_cycle2 = [&](int u, int v) {
			vector<int> l{ u }, r{ v };
			while (l.back() != par2[l.back()])
				l.emplace_back(par2[l.back()]);
			while (r.back() != par2[r.back()])
				r.emplace_back(par2[r.back()]);
			reverse(ALL(r));
			for (auto y: r)
				l.emplace_back(y);
			return l;
		};
		for (auto [u,v]: nt) {
			cerr _ "uv" _ u _ v _ endl;
			par2.assign(n, -1);
			flag.assign(n, -1);
			par2[u] = u; flag[u] = 1;
			par2[v] = v; flag[v] = 2;
			found.clear();
			cerr _ "tree u:";
			dfs2(u, u);
			cerr _ endl;
			cerr _ "tree v:";
			auto r = dfs2(v, v);
			cerr _ endl;
			cerr _ "found"; for (auto [x,y]: found) cerr _ x _ y _ '/'; cerr _ endl;
			if (r) {
				ans.emplace_back( calc_cycle(u, v) );
				found.erase({ min(u, v), max(u, v) });
				auto [x,y] = *found.begin();
				cerr _ x _ y _ endl;
				ans.emplace_back( calc_cycle2(x, y) );
				break;
			}
		}
	}
	
	if (ans.empty()) {
		cout << -1 << endl;
	} else {
		auto l = ans[0].size();
		cout << l << endl;
		for (auto& v: ans) {
			for (int i = 0; i < l; i++)
				cout << v[i]+1 << " \n"[i+1==l];
		}
	}

	return 0;
}