// This is my template for fast solving

#include <iostream>
#include <fstream>
#include <sstream>
#include <algorithm>
#include <utility>
#include <unordered_map>
#include <map>
#include <unordered_set>
#include <set>
#include <vector>
#include <string>
#include <cmath>
#include <queue>
#include <memory>
#include <initializer_list>
#include <iomanip>
#include <stack>
#include <bitset>
#include <cstdio>
// #include <complex>
// #include <random>
 
using namespace std;
 
using ll = long long;
using ull = unsigned long long;
using ld = long double;
// const ll INF = 1e18;
// const ld INF = 1e20;
// const ll MOD = 1e9 + 7;
// const ld EPS = 1e-10;
// const ld PI = acos(-1);

template<typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
    for (size_t i = 0; i < v.size(); ++i) {
        os << v[i];
        if (i + 1 != v.size()) {
            os << " ";
        }
    }
    return os;
}

// struct Node {

//     Node (int k, int v): l(nullptr), r(nullptr), key(k), value(v), size(1) {}

//     Node* l;
//     Node* r;
//     int key;
//     int value;
//     size_t size;
// };

// Node* insert(Node* p, Node* x) {
//     if (p == nullptr) {
//         return x;
//     }
//     if (p->key > x->key) {
//         p->l = insert(p->l, x);
//     } else {
//         p->r = insert(p->r, x);
//     }
//     p->size += 1;
//     return p;
// }

// size_t size(Node* p) {
//     if (p == nullptr) {
//         return 0;
//     }
//     return p->size;
// }

// Node* find(Node* p, int k) {
//     if (size(p->l) >= k) {
//         return find(p->l, k);
//     }
//     if (size(p->l) + 1 == k) {
//         return p;
//     }
//     return find(p->r, k - size(p->l) - 1);
// }

int foo(ll x) {
    int res = 0;
    while (x) {
        ++res;
        x /= 10;
    }
    return res;
}

vector<vector<int>> g;
map<pair<int, int>, int> ind;
vector<int> res;
vector<int> used;

void dfs(int v, int bad) {
    used[v] = 1;
    int color = 1;
    for (int u : g[v]) {
        if (!used[u]) {
            if (color == bad) {
                ++color;
            }
            res[ind[{u, v}]] = color;
            dfs(u, color);
            ++color;
        }
    }
}

void solve() {
    int n;
    cin >> n;
    g.resize(n);
    res.resize(n - 1);
    used.resize(n);
    int d = 0;
    for (int i = 0; i < n - 1; ++i) {
        int a, b;
        cin >> a >> b;
        --a;
        --b;
        ind[{a, b}] = i;
        ind[{b, a}] = i;
        g[a].push_back(b);
        g[b].push_back(a);

        d = max(d, (int)g[a].size());
        d = max(d, (int)g[b].size());
    }
    cout << d << "\n"; 
    dfs(0, 0);
    for (int x : res) {
        cout << x << "\n";
    }
}

int main() {
    // freopen("input.txt", "r", stdin);
    // freopen("output.txt", "w", stdout);

    // int q;
    // cin >> q;
    // while (q--) {
    //     solve();
    // }

    solve();

    // Node* root = nullptr;

    // root = insert(root, new Node(1, 1));
    // root = insert(root, new Node(2, 2));
    // root = insert(root, new Node(3, 3));
    // root = insert(root, new Node(4, 4));

    // auto res = find(root, 4);

    // cout << res->key << " " << res->value << "\n";

    return 0;
}


Measured memory_bytes: 19328