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 Main {

    public static void main(String[] args) throws IOException {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskB solver = new TaskB();
        solver.solve(in, out);
        out.close();
    }

    private static class TaskB {

        static final long max = 10000000000000000L;
        static final double eps = 0.000001;


        void solve(InputReader in, PrintWriter out) throws IOException {

            int n = in.nextInt();

            QuickUnion qu = new QuickUnion(n);
            List<Edge> pair = new ArrayList<>();
            List<Integer>[] adj = new ArrayList[n];
            int parent[] = new int[n];
            boolean visited[] = new boolean[n];
            List<SCC> sccList = new ArrayList<>();

            for (int i = 0; i < n; i++)
                adj[i] = new ArrayList<>();

            for (int i = 0; i < n - 1; i++) {

                int a = in.nextInt();
                int b = in.nextInt();

                a--;
                b--;

                if (qu.connected(a, b)) {
                    pair.add(new Edge(a, b));
                } else qu.union(a, b);

                adj[a].add(b);
                adj[b].add(a);
            }

            if (pair.size() == 0) {
                out.println(0);
                return;
            }

            out.println(pair.size());

            for (int i = 0; i < n; i++) {
                if (!visited[i]) {
                    SCC scc = new SCC(false, new ArrayList<>());
                    bfs(i, adj, visited, parent, scc);
                    sccList.add(scc);
                }
            }

            int idx = 0;

            for (int i = 0; i < sccList.size() - 1; i++) {
                int a = pair.get(idx).a + 1;
                int b = pair.get(idx).b + 1;
                int a2 = sccList.get(i).vertex.get(0) + 1;
                int b2 = sccList.get(i + 1).vertex.get(0) + 1;
                out.println(a + " " + b + " " + a + " " + a2 + " " + b2);
                idx++;
            }
        }

        void bfs(int v, List<Integer> adj[], boolean visited[], int parent[], SCC scc) {

            Queue<Integer> q = new LinkedList<>();

            q.add(v);
            visited[v] = true;

            while (!q.isEmpty()) {

                v = q.poll();
                scc.vertex.add(v);

                for (int i = 0; i < adj[v].size(); i++) {
                    int w = adj[v].get(i);
                    if (visited[w] && parent[v] != w) scc.hasCycle = true;
                    if (!visited[w]) {
                        visited[w] = true;
                        parent[w] = v;
                        q.add(w);
                    }
                }
            }

        }

        class SCC {
            boolean hasCycle;
            List<Integer> vertex;

            public SCC(boolean hasCycle, List<Integer> vertex) {
                this.hasCycle = hasCycle;
                this.vertex = vertex;
            }

            public String toString() {
                String s = "" + hasCycle + " ";
                for (int i = 0; i < vertex.size(); i++)
                    s += (vertex.get(i) + " ");
                return s;
            }
        }

        class QuickUnion {

            private final int id[];
            private final int sz[];

            public QuickUnion(int n) {
                id = new int[n];
                sz = new int[n];
                for (int i = 0; i < n; i++) {
                    id[i] = i;
                    sz[i] = 1;
                }
            }

            public int root(int i) {
                while (i != id[i]) {
                    id[i] = id[id[i]];
                    i = id[i];
                }
                return i;
            }

            public boolean connected(int p, int q) {
                return root(p) == root(q);
            }

            public void union(int p, int q) {
                int i = root(p);
                int j = root(q);
                if (sz[i] < sz[j]) {
                    id[i] = j;
                    sz[j] += sz[i];
                } else {
                    id[j] = i;
                    sz[i] += sz[j];
                }
            }

        }

        class Vertex {
            int v, root;

            Vertex(int v, int root) {
                this.v = v;
                this.root = root;
            }
        }

        class Edge {
            int a, b;

            Edge(int a, int b) {
                this.a = a;
                this.b = b;
            }
        }

        double segment(double x1, double y1, double x2, double y2) {
            return Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
        }

        long gcd(long a, long b) {
            if (b == 0) return a;
            return gcd(b, a % b);
        }

        long lcm(long a, long b) {
            return (a * b) / gcd(a, b);
        }

    }

    private static class InputReader {
        StringTokenizer st;
        BufferedReader br;

        public InputReader(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        public InputReader(FileReader s) throws FileNotFoundException {
            br = new BufferedReader(s);
        }

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

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

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

        public String nextLine() {
            try {
                return br.readLine();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

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

        public boolean ready() {
            try {
                return br.ready();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}