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 

import java.util.*;


public class D
{
   public static void main(String[] args)
   {
      new D(new Scanner(System.in));
   }

   public D(Scanner in)
   {
      int N = in.nextInt();
      
      Graph g = new Graph(N);

      // Read in the graph
      for (int u=1; u<N; u++)
      {
         int i=in.nextInt()-1;
         int j=in.nextInt()-1;
         g.addEdge(u, i, j);
      }

      // Create teh solvers
      Connected ccs = new Connected(g.N);
      BridgeFinder bf = new BridgeFinder(g.N);

      // Solve
      ArrayList<Pair> res = new ArrayList<Pair>();
      while (true)
      {
         ArrayList<Integer> cmps = ccs.solve(g);
         if (cmps.size() <= 1) break;

         // Cut something that not a bridge and make a new edge
         bf.solve(g);
         int id = -1;
         for (int u=1; u<N; u++)
            if (!bf.isBridge[u])
            {
               id = u;
               break;
            }

         ArrayList<Integer> be = g.removeEdge(id);
         g.addEdge(id, cmps.get(0), cmps.get(1));
         res.add(new Pair(cmps.get(0)+1, cmps.get(1)+1, 
                          be.get(0)+1, be.get(1)+1));
      }

      System.out.printf("%d%n", res.size());
      for (Pair p : res)
         System.out.println(p);
   }
}

class Pair
{
   ArrayList<Integer> vs = new ArrayList<Integer>(); 

   public Pair(int a, int b, int c, int d)
   {
      vs.add(c);
      vs.add(d);
      vs.add(a);
      vs.add(b);
   }

   public String toString()
   {
      StringBuilder sb = new StringBuilder();
      for (int v : vs)
      {
         sb.append(v);
         sb.append(' ');
      }
      return sb.toString().trim();
   }
}

class Edge
{
   int eid, v;

   public Edge(int id, int to)
   {
      eid = id; v = to;
   }
}

class Graph
{
   int N;
   ArrayList<Edge>[] g;

   public Graph(int n)
   {
      N = n;
      g = new ArrayList[N];
      for (int i=0; i<N; i++)
         g[i] = new ArrayList<Edge>();
   }

   void addEdge(int id, int i, int j)
   {
      g[i].add(new Edge(id, j));
      g[j].add(new Edge(id, i));
   }

   ArrayList<Integer> removeEdge(int id)
   {
      ArrayList<Integer> res = new ArrayList<Integer>();
      for (int i=0; i<N; i++)
      {
         for (int j=0; j<g[i].size(); j++)
         {
            Edge e = g[i].get(j);
            if (e.eid == id)
            {
               g[i].remove(j);
               res.add(i);
               break;
            }
         }
      }
      return res;
   }
}

class BridgeFinder
{
   int[] low;
   int[] pre;
   int cnt;
   boolean[] isBridge;

   public BridgeFinder(int n)
   {
      low = new int[n];
      pre = new int[n];
      isBridge = new boolean[n];
   }

   void solve(Graph g)
   {
      for (int v=0; v<g.N; v++)
         low[v] = pre[v] = -1;
      Arrays.fill(isBridge, false);

      for (int v=0; v<g.N; v++)
         if (pre[v] == -1)
            dfs(g, v, v);
   }

   void dfs(Graph g, int u, int v)
   {
      pre[v] = cnt++;
      low[v] = pre[v];
      for (Edge e : g.g[v])
      {
         if (pre[e.v] == -1)
         {
            dfs(g, v, e.v);
            low[v] = Math.min(low[v], low[e.v]);
            if (low[e.v] == pre[e.v])
               isBridge[e.eid] = true;
         }
         else if (e.v != u)
            low[v] = Math.min(low[v], pre[e.v]);
      }
   }
}

class Connected
{
   boolean[] visited;

   public Connected(int N)
   {
      visited = new boolean[N];
   }

   ArrayList<Integer> solve(Graph g)
   {
      ArrayList<Integer> res = new ArrayList<Integer>();
      Arrays.fill(visited, false);
      
      for (int i=0; i<g.N; i++)
         if (!visited[i])
         {
            res.add(i);
            dfs(g, i);
         }
      return res;
   }

   void dfs(Graph g, int i)
   {
      if (visited[i]) return;
      visited[i] = true;
      for (Edge e : g.g[i])
         dfs(g, e.v);
   }
}
