#include <bits/stdc++.h>

int32_t main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n;
    std::cin >> n;
    if (n != 100) {
        // exit(0);
    }
    std::vector<std::vector<int>> gr(n);
    for (int i = 0; i < n - 1; i++) {
        int u, v;
        std::cin >> u >> v;
        gr[u].push_back(v);
        gr[v].push_back(u);
    }
    std::vector<int> depth(n), prv(n);
    auto dfs = [&](auto dfs, int v, int f, int d) -> void {
        depth[v] = d;
        prv[v] = f;
        for (int t : gr[v]) {
            if (t != f)
                dfs(dfs, t, v, d + 1);
        }
    };
    std::pair<int, int> min(1e9, -1);
    for (int i = 0; i < n; i++) {
        dfs(dfs, i, -1, 0);
        min = std::min(min, {*std::max_element(depth.begin(), depth.end()), i});
    }
    int root = min.second;
    dfs(dfs, root, -1, 0);

    std::vector<std::vector<int>> ans;
    int T = 0;
    for (int ag = 0; ag < 2; ag++) {
        for (int i = 0; i < n; i++) {
            ans.push_back({});
            auto& vec = ans.back();
            vec.push_back(i);
            if (!ag) {
                vec.push_back(i);
            }
            auto get = [](int ag, int k0) {
                int res = 0;
                for (int k = 0; k < k0; k++) {
                    res += (k == 0 ? 1 : 3 * (1 << k - 1)) * (k % 2 == ag);
                }
                return res;
            };
            // if (depth[i] % 3 == 1) {
            //     vec.push_back(prv[vec.back()]);
            // } else {
            //     vec.push_back(vec.back());
            // }
            // vec.push_back({vec.back()});

            for (int k = 0; vec.back() != root; k++) {
                for (int j = 0; j < 1.6 * (k == 0 ? 1 : 3 * (1 << k - 1)) && vec.back() != root; j++) {
                    if (k % 2 == ag) {
                        vec.push_back(prv[vec.back()]);
                    } else {
                        vec.push_back(vec.back());
                    }
                    vec.push_back({vec.back()});
                }
            }
            T = std::max<int>(T, vec.size());
        }
    }

    for (int i = 0; i < 2 * n; i++) {
        ans[i].resize(T, ans[i].back());
    }
    double max_cum = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i == j) {
                continue;
            }
            for (int t = 0; t < T; t++) {
                if (ans[i][t] == ans[n + j][t]) {
                    auto lca = [&](int u, int v) {
                        if (depth[u] < depth[v]) {
                            std::swap(u, v);
                        }
                        while (depth[u] != depth[v]) {
                            u = prv[u];
                        }
                        while (u != v) {
                            u = prv[u], v = prv[v];
                        }
                        return u;
                    };
                    max_cum = std::max(max_cum, (t + 1) / double(depth[i] + depth[j] - 2 * depth[lca(i, j)]));
                    break;
                }
            }
        }
    }
    std::cerr << "max_cum: " << max_cum << std::endl;
    assert(max_cum < 17);

    std::cout << T << "\n";
    for (int i = 0; i < 2 * n; i++) {
        for (int j = 0; j < T; j++) {
            std::cout << ans[i][j] << " \n"[j == T - 1];
        }
    }

    return 0;
}