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 
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
vector<pair<long long, long long> > extra;
class DSU {
  vector<long long> parent, size;
  long long m_count, m_total;
  vector<list<long long> > parts;

 public:
  DSU(long long n) {
    m_count = m_total = n;
    parent.resize(n);
    size.resize(n);
    parts.resize(n);
    for (long long i = 0; i < n; i++) {
      parent[i] = i;
      size[i] = 1;
      parts[i].push_back(i);
    }
  }
  long long find_root(long long v) {
    if (parent[v] == v) return v;
    return parent[v] = find_root(parent[v]);
  }
  long long count() { return m_count; }
  long long total() { return m_total; }
  void join(long long a, long long b) {
    a = find_root(a);
    b = find_root(b);
    if (a != b) {
      if (size[a] < size[b]) {
        swap(a, b);
      }
      parent[b] = a;
      size[a] += size[b];
      parts[a].splice(parts[a].end(), parts[b]);
      --m_count;
    }
  }
  bool is_connected(long long u, long long v) {
    return find_root(u) == find_root(v);
  }
  void print_components() {
    vector<long long> roots;
    for (long long i = 0; i < parts.size(); i++) {
      if (parts[i].size() <= 0) continue;
      roots.push_back(find_root(*parts[i].begin()));
    }
    for (long long i = 0; i < roots.size() - 1; i++) {
      cout << extra[i].first + 1 << " " << extra[i].second + 1 << " "
           << roots[i] + 1 << " " << roots[i + 1] + 1 << "\n";
    }
  }
};
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  long long n;
  cin >> n;
  DSU dsu(n);
  for (long long i = 1; i < n; i++) {
    long long u, v;
    cin >> u >> v;
    u--, v--;
    if (dsu.is_connected(u, v))
      extra.push_back(make_pair(u, v));
    else {
      dsu.join(u, v);
    }
  }
  assert(extra.size() + 1 == dsu.count());
  cout << extra.size() << "\n";
  dsu.print_components();
  return 0;
}
