#include <algorithm>
#include <array>
#include <functional>
#include <iostream>
#include <vector>

using namespace std;

struct Tree {
    int n;
    vector<vector<pair<int, int>>> e;
    vector<int> sz, vis;
    vector<pair<int, int>> fa;
    vector<vector<int>> vec;
    Tree(int _n)
        : n(_n), e(n * 2 + 1), sz(n * 2 + 1), vis(n * 2 + 1), fa(n * 2 + 1), vec(n * 2 + 1) {
        vector<vector<pair<int, int>>> ex(n + 1);
        for (int i = 1; i < n; i++) {
            int u, v, w;
            cin >> u >> v >> w;
            ex[u].emplace_back(v, w);
            ex[v].emplace_back(u, w);
        }
        auto build = [&](auto self, int v, int fa) -> void {
            int lst = v;
            for (auto [u, c] : ex[v]) {
                if (u != fa) {
                    self(self, u, v);
                    e[u].emplace_back(u + n, c);
                    e[u + n].emplace_back(u, c);
                    e[u + n].emplace_back(lst, 0);
                    e[lst].emplace_back(u + n, 0);
                    lst = u + n;
                }
            }
        };
        build(build, 1, 1);
    }
    int getsz(int v) {
        vis[v] = true, sz[v] = 1;
        for (auto [u, c] : e[v]) {
            if (!vis[u]) {
                sz[v] += getsz(u);
            }
        }
        vis[v] = false;
        return sz[v];
    }
    int getrt(int v, int tot) {
        vis[v] = true;
        int r = v;
        for (auto [u, c] : e[v]) {
            if (!vis[u]) {
                fa[u] = {v, c};
                if (min(tot - sz[u], sz[u]) > min(tot - sz[r], sz[r])) {
                    r = u;
                }
                int x = getrt(u, tot);
                if (min(tot - sz[x], sz[x]) > min(tot - sz[r], sz[r])) {
                    r = x;
                }
            }
        }
        vis[v] = false;
        return r;
    }
    void append(int v, int dep, int sgn) {
        vis[v] = true;
        vec[v].emplace_back(dep);
        for (auto [u, c] : e[v]) {
            if (!vis[u]) {
                append(u, dep + c * sgn, sgn);
            }
        }
        vis[v] = false;
    }    
    void add(int v, int i, int d) {
        vis[v] = true;
        vec[v][i] += d;
        for (auto [u, c] : e[v]) {
            if (!vis[u]) {
                add(u, i, d);
            }
        }
        vis[v] = false;
    }
    void solve(int v) {
        int tot = getsz(v);
        if (tot == 1) {
            return;
        }
        int r = getrt(v, tot);
        int x = fa[r].first, y = r, c = fa[r].second;
        vis[y] = true, solve(x), vis[y] = false;
        vis[x] = true, solve(y), vis[x] = false;
        if (vec[x].size() > vec[y].size()) {
            swap(x, y);
        }
        vis[y] = true;
        while (vec[x].size() < vec[y].size()) {
            append(x, vec[y][vec[x].size()] + c, 0);
        }
        for (int i = 0; i < (int)vec[x].size(); i++) {
            int d = vec[y][i] + c - vec[x][i];
            add(x, i, d);
        }
        append(x, 0, -1), vis[y] = false;
        vis[x] = true, append(y, c, 1);
        vis[x] = false;
    }
};

void solve() {
    int n;
    cin >> n;
    Tree tr(n);
    tr.solve(1);
    cout << tr.vec[1].size() << '\n';
    for (int i = 1; i <= n; i++) {
        for (auto v : tr.vec[i]) {
            cout << v << ' ';
        }
        cout << '\n';
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    int T = 1;
    while (T--) {
        solve();
    }
    return 0;
}