#include <algorithm>
#include <array>
#include <ios>
#include <iostream>
#include <utility>
#include <vector>

template <typename F>
class YCombinator {

private:

    const F f = nullptr;

public:

    explicit YCombinator(F&& f) : f(f) {}

    template <typename... Args>
    decltype(auto) operator()(Args&&... args) const {

        return f(*this, std::forward<Args>(args)...);

    }

};

template <typename F>
YCombinator(F) -> YCombinator<F>;

auto solve() {

    auto n = 0;

    std::cin >> n;

    auto adj = std::vector<std::vector<int>>(n);

    for (auto i = 0; i < n - 1; ++i) {
        auto rm_1 = 0;
        auto rm_2 = 0;
        std::cin >> rm_1 >> rm_2;
        adj[rm_1].push_back(rm_2);
        adj[rm_2].push_back(rm_1);
    }

    auto mn = n;
    auto pars = std::vector<int>(n);
    auto rt = -1;
    auto v = std::array<std::vector<std::vector<int>>, 2>();

    for (auto i = 0; i < n; ++i) {
        auto mx_dep = 0;
        YCombinator(
            [&](auto self, int node, int par, int dep) -> void {
                mx_dep = std::max(mx_dep, dep);
                for (auto x : adj[node]) {
                    if (x != par) {
                        self(x, node, dep + 1);
                    }
                }
            }
        )(i, -1, 0);
        if (mx_dep < mn) {
            rt = i;
            mn = mx_dep;
        }
    }

    YCombinator(
        [&](auto self, int node, int par) -> void {
            pars[node] = par;
            for (auto x : adj[node]) {
                if (x != par) {
                    self(x, node);
                }
            }
        }
    )(rt, rt);

    for (auto& x : v) {
        x.resize(n);
    }

    for (auto i = 0; i < n; ++i) {
        auto& v_e = v[1][i];
        auto& v_o = v[0][i];
        v_o.push_back(pars[i]);
        v_e.push_back(i);
        for (auto j = 1; 1 << j < mn * 4; ++j) {
            if (j % 2 == 0) {
                for (auto k = 0; k < 1 << j; ++k) {
                    if (k) {
                        v_o.push_back(v_o.back());
                        v_e.push_back(v_e.back());
                    }
                    v_o.push_back(pars[v_o.back()]);
                    v_e.push_back(v_e.back());
                }
            } else {
                for (auto k = 0; k < 1 << j; ++k) {
                    if (k) {
                        v_o.push_back(v_o.back());
                        v_e.push_back(v_e.back());
                    }
                    v_o.push_back(v_o.back());
                    v_e.push_back(pars[v_e.back()]);
                }
            }
        }
    }

    const auto t = static_cast<int>(std::size(v[0][0]));

    std::cout << t << '\n';

    for (const auto& x : v) {
        for (const auto& y : x) {
            for (auto i = 0; i < t; ++i) {
                std::cout << y[i] << (i < t - 1 ? ' ' : '\n');
            }
        }
    }

}

auto main() -> int {

    std::cin.tie(nullptr);

    std::ios_base::sync_with_stdio(false);

    solve();

    return 0;

}