4
1 4
3 1
3 4
 5
4 1
4 3
5 3
2 4
 21
7 15
13 1
14 3
4 10
2 3
16 18
17 20
16 20
8 4
3 12
2 17
13 11
16 1
13 2
13 5
8 9
6 14
3 17
16 9
13 8
 3
3 1
3 2
 6
5 2
5 3
1 4
3 1
5 6
 60
17 34
46 22
50 44
46 33
41 21
31 33
48 6
38 19
35 60
2 24
49 29
7 53
34 1
19 55
32 1
31 42
27 28
4 53
6 50
21 34
1 10
12 36
54 8
16 13
51 43
45 51
54 20
13 53
34 33
49 33
51 11
59 34
15 5
59 28
30 39
13 30
58 4
34 14
3 9
19 34
4 18
26 48
56 54
3 43
57 25
3 41
35 3
48 44
19 13
54 1
23 31
59 47
5 1
46 40
6 26
20 25
37 5
17 24
20 52
 3
3 2
1 2
 39
6 13
15 39
10 35
31 28
4 21
12 39
3 7
3 13
6 1
5 14
36 28
12 15
18 38
30 29
19 34
36 16
20 22
8 13
38 32
26 39
21 37
1 7
15 27
12 26
8 3
6 14
29 2
25 23
32 21
5 16
32 25
6 8
13 10
23 30
34 37
29 33
28 14
36 5
 10
5 9
8 5
7 6
7 9
3 9
2 1
7 2
3 6
7 1

1
3 4 1 2  0
 3
13 2 1 7 3 17 1 19 13 8 1 21  0
 0
 2
48 44 1 6 6 26 1 12  0
 7
12 15 1 2 1 7 1 9 12 26 1 11 8 3 1 12 6 8 1 17 28 14 1 20 36 5 1 24  2
3 6 1 4 7 1 1 10 
/*
        ######## ##   ## #######          ##########
           ##    ##   ## ##                 ##    ##
           ##    ####### ######             ##    ##
           ##    ##   ## ##                 ##    ##
           ##    ##   ## ####### ######## ##########
    */
    #pragma GCC optimize("Ofast")
    #pragma GCC optimize("unroll-loops")
    #pragma GCC target("sse2")
    #include<bits/stdc++.h>
    #include <ext/pb_ds/assoc_container.hpp>
    #include <ext/pb_ds/tree_policy.hpp>
    #define int         long long
    #define pb          push_back
    #define pii         pair<int,int>
    #define vi          vector<int>
    #define vii         std::vector<vector<int> > v;
    #define all(a)      (a).begin(),(a).end()
    #define F           first
    #define S           second
    #define hell        1000000007
    #define endl        "\n"
    using namespace std;
    using namespace __gnu_pbds;
    #define rn return   
    #define INF LONG_MAX
    #define M 998244353 
    #define yes                cout << "YES" << endl
    #define no                 cout << "NO" << endl
    #define error(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); }

    void err(istream_iterator<string> it) {}
    template<typename T, typename... Args>
    void err(istream_iterator<string> it, T a, Args... args) {
        cerr << *it << " = " << a << " | ";
        err(++it, args...);
    }

    #define rep(i, begin, end) for (__typeof(end) i = (begin) - ((begin) > (end)); i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
    typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> pbds;
 
    void solve();
    int absval(int x){
        if(x>=0) rn x;
        else rn -1*x;
    }
    int power(int n, int m, int mod = hell){
        if(m==0) rn 1;
        int x = power(n,m/2,mod)%mod;
        if(m%2) rn (((x*x)%mod)*n)%mod;
        else rn (x*x)%mod;
    }
    signed main()
    {
        ios_base::sync_with_stdio(false);
        cin.tie(0);
        cout.tie(0);
        int TESTS=1;
        // cin>>TESTS;
        while(TESTS--)
        {
            solve();
            
        }
        return 0;
    }
 
    const int N = 1e3 + 5;
    const int K = 19; 
    vi adj[N], vis(N),cc, par(N);
    map<int,vector<pii>> m;
    void dfs(int v, int root){
    	if(vis[v] == 2) return ;
    	if(vis[v]){
    		m[root].pb({par[v],v});
    		return ;
    	}
    	vis[v] = 1;
    	for(int x: adj[v]){
    		if(x == par[v]) continue;
    		par[x] = v;
    		dfs(x,root);
    	}
    	vis[v] = 2;
    }
    void solve(){
    	int n;
    	cin>>n;
    	int x,y;
    	rep(i,0,n-1){
    		cin>>x>>y;
    		adj[x].pb(y);
    		adj[y].pb(x);
    	}	
    	rep(i,1,n+1){
    		if(!vis[i]){
    			par[i] = -1;
    			cc.pb(i);
    			dfs(i,i);
    		}
    	}
    	int t = 0;
    	vector<pii> l,r;
    	rep(i,1,cc.size()){
    		r.pb({cc[0], cc[i]});
    	}
    	auto it = m.begin();
    	while(it != m.end()){
    		if(t == cc.size()-1) break;
    		for(auto x: it->S){
    			if(t == cc.size()-1) break;
    			l.pb(x);
    			t++;
    		}
    		it++;
    	}
    	cout<<l.size()<<endl;
    	rep(i,0,l.size()) cout<<l[i].F<<" "<<l[i].S<<" "<<r[i].F<<" "<<r[i].S<<endl;
    }   