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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Iterator;
import java.io.BufferedWriter;
import java.util.Set;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Egor Kulikov (egor@egork.net)
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		OutputWriter out = new OutputWriter(outputStream);
		TaskD solver = new TaskD();
		solver.solve(1, in, out);
		out.close();
	}

	static class TaskD {
		int[] dsu;
		Set<Integer> groups;

		public void solve(int testNumber, InputReader in, OutputWriter out) {
			int n = in.readInt();
			List<IntPair> roadsToRemove = new ArrayList<>(n);
			dsu = new int[n];
			dsuInit();
			for (int i = 0; i < n - 1; i++) {
				int from = in.readInt() - 1;
				int to = in.readInt() - 1;
				if (!tryUnite(from, to))
					roadsToRemove.add(new IntPair(from, to));
			}

			out.printLine(roadsToRemove.size());
			roadsToRemove.forEach(road -> {
				int from = road.first;
				int to = road.second;

				int newFrom = from;
				int newTo;
				Iterator<Integer> iter = groups.iterator();
				if ((newTo = iter.next()) == dsuFindSet(newFrom))
					newTo = iter.next();
				tryUnite(newFrom, newTo);

				out.printFormat("%d %d %d %d\n", ++from, ++to, ++newFrom, ++newTo);
			});
		}

		boolean tryUnite(int i, int j) {
			int p1 = dsuFindSet(i);
			int p2 = dsuFindSet(j);

			if (p1 != p2) {
				dsu[p2] = p1;
				groups.remove(p2);
				return true;
			} else {
				return false;
			}
		}

		int dsuFindSet(int i) {
			if (dsu[i] == i) return i;
			return dsu[i] = dsuFindSet(dsu[i]);
		}

		void dsuInit() {
			groups = new HashSet<>(dsu.length);
			for (int i = 0; i < dsu.length; i++)
				groups.add(dsu[i] = i);
		}

	}

	static class OutputWriter {
		private final PrintWriter writer;

		public OutputWriter(OutputStream outputStream) {
			writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
		}

		public OutputWriter(Writer writer) {
			this.writer = new PrintWriter(writer);
		}

		public void printFormat(String format, Object... objects) {
			writer.printf(format, objects);
		}

		public void close() {
			writer.close();
		}

		public void printLine(int i) {
			writer.println(i);
		}

	}

	static class IntPair implements Comparable<IntPair> {
		public final int first;
		public final int second;

		public IntPair(int first, int second) {
			this.first = first;
			this.second = second;
		}


		public String toString() {
			return "(" + first + "," + second + ")";
		}


		public boolean equals(Object o) {
			if (this == o) return true;
			if (o == null || getClass() != o.getClass()) return false;

			IntPair intPair = (IntPair) o;

			return first == intPair.first && second == intPair.second;

		}


		public int hashCode() {
			int result = first;
			result = 31 * result + second;
			return result;
		}

		public int compareTo(IntPair o) {
			if (first < o.first)
				return -1;
			if (first > o.first)
				return 1;
			if (second < o.second)
				return -1;
			if (second > o.second)
				return 1;
			return 0;
		}

	}

	static class InputReader {
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;
		private SpaceCharFilter filter;

		public InputReader(InputStream stream) {
			this.stream = stream;
		}

		public int read() {
			if (numChars == -1)
				throw new InputMismatchException();
			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public int readInt() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			int res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} while (!isSpaceChar(c));
			return res * sgn;
		}

		public boolean isSpaceChar(int c) {
			if (filter != null)
				return filter.isSpaceChar(c);
			return isWhitespace(c);
		}

		public static boolean isWhitespace(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		public interface SpaceCharFilter {
			public boolean isSpaceChar(int ch);

		}

	}
}
