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.io.*;
    import java.util.*;
 public class d {
     static int n;
     static ArrayList<Integer>[] g;
     static boolean[] vis;
     static ArrayList<pair> close = new ArrayList<>();

     public static void main(String args[]) throws IOException {
         InputStream inputStream = System.in;
         OutputStream outputStream = System.out;
         InputReader sc = new InputReader(inputStream);
         PrintWriter out = new PrintWriter(outputStream);
         n = sc.nextInt();
         g = new ArrayList[n + 1];
         vis = new boolean[n + 1];
         for (int i = 0; i <= n; i++)
             g[i] = new ArrayList<>();
         for (int i = 0; i < n - 1; i++) {
             int a = sc.nextInt(), b = sc.nextInt();
             g[a].add(b);
             g[b].add(a);
         }
         ArrayList<pair> build = new ArrayList<>();
         int prev = 0;
         for (int i = 1; i <= n; i++) {
             if (!vis[i]) {
                 dfs(i, -1);
                 if (i != 1) {
                     build.add(new pair(prev, i));
                 }
                 prev = i;
             }
         }
         System.out.println(build.size());
         for (int i = 0; i < build.size(); i++) {
             out.println(close.get(i).from + " " + close.get(i).to + " " + build.get(i).from + " " + build.get(i).to);
         }

         out.close();
     }

     static void dfs(int u, int prev) {
         vis[u] = true;
         for (int v : g[u]
                 ) {
             if (!vis[v]) {
                 dfs(v, u);
             } else if (prev != v && prev != -1) {
                 close.add(new pair(u, v));
             }


         }
     }

     public static void shuffle(long[] arr) {
         int n = arr.length;
         Random rnd = new Random();
         for (int i = 0; i < n; ++i) {
             long tmp = arr[i];
             int randomPos = i + rnd.nextInt(n - i);
             arr[i] = arr[randomPos];
             arr[randomPos] = tmp;
         }
     }

     public static void shuffle(int[] arr) {
         int n = arr.length;
         Random rnd = new Random();
         for (int i = 0; i < n; ++i) {
             int tmp = arr[i];
             int randomPos = i + rnd.nextInt(n - i);
             arr[i] = arr[randomPos];
             arr[randomPos] = tmp;
         }
     }

     public static int gcd(int x, int y) {
         if (y == 0)
             return x;
         return gcd(y, x % y);
     }

     static class InputReader {
         public BufferedReader reader;
         public StringTokenizer tokenizer;

         public InputReader(InputStream stream) {
             reader = new BufferedReader(new InputStreamReader(stream), 32768);
             tokenizer = null;
         }

         public String next() {
             while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                 try {
                     tokenizer = new StringTokenizer(reader.readLine());
                 } catch (IOException e) {
                     throw new RuntimeException(e);
                 }
             }
             return tokenizer.nextToken();
         }

         public int nextInt() {
             return Integer.parseInt(next());
         }

         public long nextLong() {
             return Long.valueOf(next());
         }

         public double nextDouble() {
             return Double.valueOf(next());
         }

         String nextLine() throws IOException {
             return reader.readLine();
         }

     }
 }
 class pair {
     int from, to;

     pair(int from, int to) {
         this.from = from;
         this.to = to;
     }
 }