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.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.StringTokenizer;

public class RoadsNotOnlyInBerland {
    static ArrayList<Edge> EdgeList=new ArrayList();
    static ArrayList<Edge> MST=new ArrayList();
    
	public static void main(String[] args) throws IOException {
		Scanner sc=new Scanner(System.in);
		PrintWriter pw=new PrintWriter(System.out);
		int n=sc.nextInt();
		ArrayList<Edge> build=new ArrayList(); 
		ArrayList<Edge> remove=new ArrayList(); 
        DSU dsu=new DSU(n);
     
		while(sc.ready()) {
			
//          System.out.println("waitin" +ctr);
			int i=sc.nextInt();
			int j=sc.nextInt();		
			EdgeList.add(new Edge(i,j)); 

		}
		for(Edge curr:EdgeList){
			if(!dsu.isSameSet(curr.i-1,curr.j-1)) {
				dsu.union(curr.i-1,curr.j-1);
				MST.add(curr);
			}
		}
		
		for(int i1=0;i1<n;i1++) {
			for(int z=0;z<n;z++) {
				if(i1==z)
					continue;
				if(!dsu.isSameSet(i1,z)) {
					MST.add(new Edge(i1+1,z+1));
					dsu.union(i1, z);
				}
			}
		}
//		String build="";
		for(Edge e:MST) {
//			System.out.println("MST has "+e);
			if(!EdgeList.contains(e)) {
				build.add(e);
			}
		}
		for(Edge e:EdgeList) {
			if(!MST.contains(e)) {
				remove.add(e);
			}		

		}		
		System.out.println(build.size());

		while(!build.isEmpty()) {
			pw.println(remove.get(0)+" "+build.get(0));
			build.remove(0);
			remove.remove(0);
		}
		pw.flush();
		
	}


  static class Edge implements Comparable <Edge>{
	  int i;
	  int j;
 
	  public Edge(int i,int j) {
		  this.i=i;
		  this.j=j;
	  }

	
	public int compareTo(Edge o) {
		if(i==o.i && j==o.j || i==o.j && j==o.i)
		  return 0;
		else return -1;
	}
	public String toString() {
		return i+" "+j;
	}


  }
  static class DSU
  {
      int sets;
      int[] rank, parent;

      public DSU(int size)
      {
          this.sets = size;
          this.rank = new int[size];
          this.parent = new int[size];
          for(int i = 0; i < size; i++)
          {
              this.parent[i] = i;
          }
      }

      public int findSet(int i)
      {
          return i == parent[i] ? i : (parent[i] = this.findSet(parent[i]));
      }

      public boolean isSameSet(int i, int j)
      {
          return this.findSet(i) == this.findSet(j);
      }

      public void union(int i, int j)
      {
          if(this.isSameSet(i, j))
              return;
          
          sets--;
          int ii = this.findSet(i);
          int jj = this.findSet(j);
          if(rank[ii] > rank[jj])
          {
              parent[jj] = ii;
          }
          else
          {
              parent[ii] = jj;
              if(rank[ii] == rank[jj]) rank[jj]++;
          }
      }

    

    
  }
	
	static class Scanner 
	{
	    StringTokenizer st;
	    BufferedReader br;

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

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

	    public int nextInt() throws IOException {return Integer.parseInt(next());}
	    
	    public long nextLong() throws IOException {return Long.parseLong(next());}

	    public String nextLine() throws IOException {return br.readLine();}
	    
	    public double nextDouble() throws IOException
	    {
	        String x = next();
	        StringBuilder sb = new StringBuilder("0");
	        double res = 0, f = 1;
	        boolean dec = false, neg = false;
	        int start = 0;
	        if(x.charAt(0) == '-')
	        {
	            neg = true;
	            start++;
	        }
	        for(int i = start; i < x.length(); i++)
	            if(x.charAt(i) == '.')
	            {
	                res = Long.parseLong(sb.toString());
	                sb = new StringBuilder("0");
	                dec = true;
	            }
	            else
	            {
	                sb.append(x.charAt(i));
	                if(dec)
	                    f *= 10;
	            }
	        res += Long.parseLong(sb.toString()) / f;
	        return res * (neg?-1:1);
	    }
	    
	    public boolean ready() throws IOException {return br.ready();}


	}
}
