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 
/**
 *
 * @author sarthak
 */

import java.util.*;
import java.math.*;
import java.io.*;



public class rnd25_D {

    static class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(InputStream is) {
            br = new BufferedReader(new InputStreamReader(is));
        }

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

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
                return "";
            }
        }

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

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

        public double nextDouble() {
            return Double.parseDouble(next());
        }
    }
    static class P implements Comparable{
        boolean HC;
        private int x;
        public P(boolean HC, int x) {
            this.HC = HC;
            this.x = x;
        }
      public int compareTo(Object obj) {
		P l = (P) obj;
		if (this.HC &&l.HC){
			if (this.x == l.x) return 0;
			return (this.x < l.x)? -1: 1;
		}
		return (this.HC)? -1: 1;
	}
    }
    static ArrayList<Integer>[] G;
    static int[] vis;
    static boolean cyc;
    static class PC{
        int u,v;
        public PC(int u,int v){
            this.u=u;
            this.v=v;
        }
        
    }
    static PC CP;//cycle pair
    public static void dfs(int v,int p){
        vis[v]=1;
        //System.out.println(v+ "-------"+p);
        if(v!=p)
            for(int ad:G[v])
                if(vis[ad]==1&&ad!=p)
                {
                    cyc=true;
                    //System.out.println(" m here baby  ");
                }
        for(int ad:G[v])
        {
            if(vis[ad]==0)
                dfs(ad,v);
        }
    }
    public static void findCyPair(int v,int p){
        vis[v]=1;
        for(int ad:G[v]){
            if(vis[ad]==1&&ad!=p&&v!=p)
            {
                CP=new PC(v,ad);return;
            }
            
        }
        for(int ad:G[v])
            if(vis[ad]==0)
                findCyPair(ad, v);
        
    }
  
    
    
    public static void main(String[] args){
         
    FastScanner s = new FastScanner(System.in);
    StringBuilder op=new StringBuilder();
    int n=s.nextInt();
    G=new ArrayList[n+1];
    
    for(int i=1;i<=n;i++)
        G[i]=new ArrayList<>();
    for(int i=1;i<=n-1;i++){
        int u=s.nextInt();
        int v=s.nextInt();
        G[u].add(v);
        G[v].add(u);
    }
        
    vis=new int[n+1];
    boolean[] hasCy=new boolean[n+1];
    int cc=0;
    ArrayList<P> roots=new ArrayList<>();
    int[] edC=new int[n+1];
    ArrayList<Integer>ROOTS=new ArrayList<>();
    for(int i=1;i<=n;i++){
        if(vis[i]==0)
        {
            cc++;
            cyc=false;
            dfs(i,i);
            ROOTS.add(i);
            hasCy[i]=cyc;
        }
    }
    if(cc==1){
        System.out.println(0);
        return;
    }
    cc--;
    
    for(int i:ROOTS){
        if(hasCy[i])
          roots.add(new P(true,i));
    }
      for(int i:ROOTS){
        if(!hasCy[i])
          roots.add(new P(false,i));
    }
  
    
  /*  for(P r:roots){
        System.out.println(r.x + " " + r.HC);
    }
  */
    
    int[] root=new int[n+1];
    for(P r:roots)
        root[r.x]=r.x;
    for(int i=0;i<roots.size()-1;i++){
        if(root[roots.get(i).x]!=root[roots.get(i+1).x]){//dsu ;)
            if(hasCy[root[roots.get(i).x]]){
                CP=null;
                Arrays.fill(vis,0);
                findCyPair(root[roots.get(i).x],root[roots.get(i).x]);
                G[CP.u].remove(new Integer(CP.v));G[CP.v].remove(new Integer(CP.u));
              
                //merging
                cyc=false;
                 Arrays.fill(vis,0);
                dfs(root[roots.get(i).x],root[roots.get(i).x]);
                if(!cyc){
                    hasCy[root[roots.get(i).x]]=false;
                    root[roots.get(i).x]=roots.get(i+1).x;
                }
                else{
                    root[roots.get(i+1).x]=root[roots.get(i).x];
                }
                G[CP.u].add(roots.get(i+1).x);//union
                op.append(CP.u +" "+CP.v +" " +CP.u +" " +roots.get(i+1).x+"\n");
            }
        }
    }
    System.out.println(cc);
    System.out.print(op);
    
    }


}
