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 
# include "conio.h"
# include "stdio.h"
# include "iostream"
# include <vector>
# include <queue>
# include "map"
using namespace std;
vector <vector <int> > gr(1000);
vector <bool> used;
vector <int> c;
vector <vector <int> > comp;
int n;
pair <int,int> chain;
vector <bool> circ;
bool fl;
void dfs (int v)
{
    used[v]=true;
    c.push_back(v);
    for (int i=0; i<gr[v].size(); i++)
        if (!used[gr[v][i]])
            dfs(gr[v][i]);
}
void comps ()
{
    for (int i=0; i<n; i++)
    {
        if (!used[i])
        {
            c.clear();
            dfs(i);
            comp.push_back(c);
        }
    }
}
void dfs2 (int v, int pr, vector <int> par)
{
    if (!fl)
    {
    for (int i=0; i<gr[v].size(); i++)
    {
         int to=gr[v][i];
         if (to!=pr)
         {
             if (!fl)
             {
                 if (par[to]!=-1)
                 {
                     fl=true;
                     break;
                     
                 }
                 par[to]=v;
                 dfs2(to,v,par);

             }
         }
    }

    }
}
bool iscicl (int i)
{
    vector <int> g=comp[i];
    used.clear();
    fl=false;
    used.assign(g.size(),false);
    vector <int> par;
    par.assign(n,-1);
    dfs2(g[0],g[0],par);
        if (fl)
            return true;

    
    return false;
}
void dfs (int v, int pr,vector <int> par)
{
    for (int i=0; i<gr[v].size(); i++)
    {
         int to=gr[v][i];
         if (to!=pr)
         {
             if (!fl)
             {
                 if (par[to]!=-1)
                 {
                     fl=true;
                     chain.first=to;
                     chain.second=v;
                 }
                 par[to]=v;
                 dfs(to,v,par);

             }
         }
    }
}
void findchain (int i)
{
    vector <int> g=comp[i];
    vector <int> pr;
    fl=false;
    pr.assign(n,-1);
    dfs(g[0],g[0], pr);
}
void correct(int p)
{
    int a=0;
    for (int i=0; i<gr[chain.first].size(); i++)
    {
        if (gr[chain.first][i]==chain.second)
            a=i;
    }
    gr[chain.first].erase(gr[chain.first].begin()+a);
    a=0;
    for (int i=0; i<gr[chain.second].size(); i++)
    {
        if (gr[chain.second][i]==chain.first)
            a=i;
    }
     gr[chain.second].erase(gr[chain.second].begin()+a);
     if (iscicl(p))
         circ[p]=true;
     else
         circ[p]=false;
}

void main()
{
    cin>>n;
    for (int i=0; i<n-1; i++)
    {
        int a,b;
        cin>>a>>b;
        gr[a-1].push_back(b-1);
        gr[b-1].push_back(a-1);
    }
    used.assign(n,false);
    comps();
    circ.assign(comp.size(),false);
    for (int i=0; i<comp.size(); i++)
    {
        if (iscicl(i))
            circ[i]=true;
            
    }
    vector <pair <int, int> > r;
    for (int i=0; i<comp.size(); i++)
    {
        if (circ[i])
        {
            findchain(i);
            correct(i);
            r.push_back(chain);
            i--;
        }
    }
    cout<<comp.size()-1<<endl;
    for (int i=0; i<comp.size()-1; i++)
    {
        cout<<r[i].first+1<<" "<<r[i].second+1<<" "<<comp[i][0]+1<<" "<<comp[i+1][0]+1<<endl;

    }
    
    
    


}
/*


10
5 9
8 5
7 6
7 9
3 9
2 1
7 2
3 6
7 1

*/