#include<bits/stdc++.h>

#define ll long long
#define mk make_pair
#define fi first
#define se second

using namespace std;

#define gc getchar
inline int read(){
	int x=0,f=1;char c=getchar();
	for(;(c<'0'||c>'9');c=getchar()){if(c=='-')f=-1;}
	for(;(c>='0'&&c<='9');c=getchar())x=x*10+(c&15);
	return x*f;
}

template<typename T>void cmax(T &x,T v){x=max(x,v);}
template<typename T>void cmin(T &x,T v){x=min(x,v);}

vector<pair<int,int> >getTree(vector<int>P){ // prufer sequence -> tree
	int n=P.size()+2;
	vector<int>deg(n,1);for(int x:P)deg[x]++;

	set<int>Leaf;vector<pair<int,int> >edges;
	for(int i=0;i<n;i++)if(deg[i]==1)Leaf.insert(i);
	for(int i=0;i<n-2;i++){
		int x=*Leaf.begin();Leaf.erase(Leaf.begin());
		int y=P[i];edges.emplace_back(mk(y,x));
		if(--deg[y]==1)Leaf.insert(y);
	}
	edges.emplace_back(mk(*Leaf.begin(),*--Leaf.end()));
	return edges;
}

void A(int x,int y,vector<vector<int> >&G){G[x][y]^=1,G[y][x]^=1;}
void oper(int a,int b,int c,int d,vector<vector<int> >&G){
	assert(G[a][b]&&G[b][c]&&G[c][d]&&a!=b&&a!=c&&a!=d&&b!=c&&b!=d&&c!=d);
	A(a,b,G),A(b,c,G),A(c,d,G),A(c,a,G),A(a,d,G),A(d,b,G);
}

const int N=1305; // 6^4 = 1296
map<vector<vector<int> >,int>ID;
vector<vector<int> >Gs[N];
int pre[N];
struct OP{int a,b,c,d;OP(int A=0,int B=0,int C=0,int D=0):a(A),b(B),c(C),d(D){}};
OP rec[N];
vector<pair<int,OP> >to[N];

OP rev(OP x){return OP(x.c,x.a,x.d,x.b);}

void prework(){
	int n=6,ncnt=0;
	vector<int>P(n-2);
	for(P[0]=0;P[0]<n;P[0]++)for(P[1]=0;P[1]<n;P[1]++)for(P[2]=0;P[2]<n;P[2]++)for(P[3]=0;P[3]<n;P[3]++){
		auto E=getTree(P);++ncnt;
		vector<vector<int> >G(n,vector<int>(n));
		for(auto [u,v]:E)G[u][v]=G[v][u]=1;
		ID[G]=ncnt,Gs[ncnt]=G;
	}
	// assert(ncnt==1296);
	for(int i=1;i<=ncnt;i++){
		auto G=Gs[i];
		for(int a=0;a<n;a++)for(int b=0;b<n;b++)for(int c=0;c<n;c++)for(int d=0;d<n;d++){
			if(a==b||a==c||a==d||b==c||b==d||c==d)continue;
			if(!G[a][b]||!G[b][c]||!G[c][d])continue;
			oper(a,b,c,d,G);
			to[i].emplace_back(mk(ID[G],OP(a,b,c,d)));
			oper(c,a,d,b,G);
		}
	}

	queue<int>Q;Q.push(34);
	while(Q.size()){
		int x=Q.front();Q.pop();
		for(auto [y,op]:to[x])if(!pre[y])pre[y]=x,rec[y]=op,Q.push(y);
	}
}

vector<OP>find_path(vector<vector<int> >G1){
	int n=G1.size();
	int x=ID[G1],y=5;
	assert(pre[x]&&pre[y]);
	vector<OP>path;
	while(x!=5)path.emplace_back(rev(rec[x])),x=pre[x];
	return path;
}

vector<OP>ans;
void add_op(int a,int b,int c,int d){ans.emplace_back(OP(a,b,c,d));}

void solve(){
	int n=read(),k=3;
	vector<vector<int> >G(n,vector<int>(n)),adj(n);
	for(int i=1;i<=n-1;i++){
		int u=read()-1,v=read()-1;
		G[u][v]=G[v][u]=1,adj[u].emplace_back(v),adj[v].emplace_back(u);
	}

	auto bfs=[&](int u){
		queue<int>q;vector<int>dis(n,-1);
		dis[u]=0;q.push(u);
		while(q.size()){
			int x=q.front();q.pop();
			for(int y=0;y<n;y++)if(G[x][y]&&dis[y]==-1)dis[y]=dis[x]+1,q.push(y);
		}
		return dis;
	};

	auto diam=[&](){
		auto dis=bfs(0);int x=0;
		for(int i=0;i<n;i++)if(dis[i]>dis[x])x=i;
		dis=bfs(x);
		for(int i=0;i<n;i++)if(dis[i]>dis[x])x=i;
		return dis[x];
	};

	if(diam()<=2)return puts("0"),void();
	if(k==2)return puts("-1"),void();
	if(n==5){
		if(diam()==4){
			auto dis=bfs(0);int x=0;
			for(int i=0;i<n;i++)if(dis[i]>dis[x])x=i;
			dis=bfs(x);vector<int>id(10);
			for(int i=0;i<n;i++)id[dis[i]]=i+1;
			puts("1");
			cout<<id[0]<<" "<<id[1]<<" "<<id[2]<<" "<<id[3]<<endl;
		}
		else puts("0");
		return ;
	}

	auto compact=[&](vector<int>nodes){
		assert(nodes.size()==6&&nodes[0]==0);
		
		vector<int>id(n);
		for(int i=0;i<6;i++)id[nodes[i]]=i;
		vector<vector<int> >G1(6,vector<int>(6));
		for(int i=0;i<6;i++)for(int j=0;j<6;j++)G1[i][j]=G[nodes[i]][nodes[j]];
		
		auto ops=find_path(G1);
		for(auto op:ops){
			auto [a,b,c,d]=op;
			a=nodes[a],b=nodes[b],c=nodes[c],d=nodes[d];
			oper(a,b,c,d,G),add_op(a,b,c,d);
		}
	};

	while(true){
		vector<int>fa(n),dep(n),d(n),hson(n,-1);
		function<void(int)>dfs=[&](int u){
			hson[u]=-1;
			for(int v=0;v<n;v++)if(G[u][v]&&fa[u]!=v){
				fa[v]=u,dep[v]=dep[u]+1,dfs(v);
				cmax(d[u],d[v]+1);if(hson[u]==-1||d[v]>d[hson[u]])hson[u]=v;
			}
		};
		dfs(0);bool hav=false;
		for(int i=0;i<n;i++)if(dep[i]>=3)hav=true;
		if(!hav)break;

		vector<int>nodes;
		function<void(int)>dfs2=[&](int u){
			if(nodes.size()==6)return ;
			nodes.emplace_back(u);
			if(hson[u]!=-1)dfs2(hson[u]);
			for(int v=0;v<n;v++)if(G[u][v]&&v!=fa[u]&&v!=hson[u])dfs2(v);
		};

		dfs2(0);
		compact(nodes);
	}

	auto output=[&](){
		cout<<ans.size()<<'\n';
		for(auto [a,b,c,d]:ans)cout<<a+1<<" "<<b+1<<" "<<c+1<<" "<<d+1<<'\n';
		vector<OP>().swap(ans);
		return ;
	};

	if(diam()<=3)return output();
	assert(diam()==4);

	while(diam()>=4){
		vector<int>fa(n),dep(n);
		function<void(int)>dfs=[&](int u){
			for(int v=0;v<n;v++)if(v!=fa[u]&&G[u][v])fa[v]=u,dep[v]=dep[u]+1,dfs(v);
		};
		dfs(0);
	
		int x=-1,y=-1;
		for(int i=0;i<n;i++)if(dep[i]==2){
			x=i;auto dis=bfs(x);
			for(int j=0;j<n;j++)if(dis[j]==4){y=j;break;}
			break;
		}
		assert(x!=-1&&y!=-1);

		int p=-1;
		for(int i=0;i<n;i++)if(i!=0&&i!=x&&i!=y&&i!=fa[x]&&i!=fa[y]){
			if(G[0][i]||G[fa[x]][i]||G[fa[y]][i])p=i;
		}
		assert(p!=-1);
		vector<int>nodes(6);
		nodes[0]=0,nodes[1]=x,nodes[2]=fa[x],nodes[3]=p,nodes[4]=fa[y],nodes[5]=y;
		compact(nodes);
	}

	assert(diam()<=3);
	output();
}

signed main(void){

#ifndef ONLINE_JUDGE
	freopen("in.txt","r",stdin);
	freopen("out.out","w",stdout);
#endif

	prework();
	int tt=1;
	while(tt--)solve();

	return 0;
}