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.*;
import java.io.*;

public class D_RoadsNotOnlyInBerland {

    //1:40
    //
    
    public static void main(String[] args) {
        Scanner s = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
        
        int n = s.nextInt();
        
        Map<Integer, Node> nodeMap = new HashMap<Integer, Node>();

        for (int i = 0; i < n-1; i++) {
            int a = s.nextInt()-1, b = s.nextInt()-1;

            Node an = nodeMap.get(a), bn = nodeMap.get(b);
            if(an == null){
                an = new Node(a);
                nodeMap.put(a, an);
            }
            if(bn == null){
                bn = new Node(b);
                nodeMap.put(b, bn);
            }
            
            an.links.add(bn);
            bn.links.add(an);
        }
        
        int gi = 0;
        List<Integer> edgecnts = new ArrayList<Integer>();
        List<Integer> nodecnts = new ArrayList<Integer>();
        
        List<Pair> deletable = new ArrayList<Pair>();
        List<Integer> represents = new ArrayList<Integer>();
        
        for (Node node : nodeMap.values()) {
            if(node.group >= 0) continue;
            
            int edgecnt = 0, nodecnt = 0;
            represents.add(node.index);
            
            
            Stack<Node> st = new Stack<Node>();
            st.push(node);
            
            
            List<Pair> path = new ArrayList<Pair>();
            List<Pair> allEdges = new ArrayList<Pair>();
            
            Node old = null;
            while(!st.empty()){
                Node cur = st.pop();
                if(cur.group >= 0) continue;
                if(old != null) path.add(new Pair(old.index, cur.index));
                
                cur.group = gi;
                edgecnt += cur.links.size();
                nodecnt++;
                for (Node l : cur.links){
                    Pair edge = new Pair(cur.index, l.index);
                    if(!allEdges.contains(edge)) allEdges.add(edge);
                    if(l.group == -1){
                        st.push(l);
                    }
                }
                old = cur;
            }
            
            for (Pair edge : allEdges) {
                if(! path.contains(edge)) deletable.add(edge);
            }
            
            edgecnts.add(edgecnt);
            nodecnts.add(nodecnt);
            gi++;
        }
        
        int grpcnt = represents.size();
        System.out.println(grpcnt-1);
        
        for (int i = 0; i < grpcnt-1; i++) {
            int df = deletable.get(i).v1;
            int dt = deletable.get(i).v2;
            int mf = represents.get(i);
            int mt = represents.get(i+1);
            
            System.out.println(String.format("%s %s %s %s", df+1, dt+1, mf+1, mt+1));
        }
        
        
    }
    
    
    private static class Node{
        int index;
        List<Node> links;
        int group;
        
        public Node(int index){
            this.index = index;
            this.group = -1;
            this.links = new ArrayList<Node>();
        }
        
        public String toString(){
            return String.valueOf(index);
        }
    }
    
    private static class Pair{
        int v1;
        int v2;
        public Pair(int v1, int v2){
            this.v1 = Math.min(v1, v2);
            this.v2 = Math.max(v1, v2);
        }
        
        public String toString(){
            return String.format("%s %s", v1, v2);
        }

        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + v1;
            result = prime * result + v2;
            return result;
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj)
                return true;
            if (obj == null)
                return false;
            if (getClass() != obj.getClass())
                return false;
            Pair other = (Pair) obj;
            if (v1 != other.v1)
                return false;
            if (v2 != other.v2)
                return false;
            return true;
        }
        
        
    }
    

}
