#include <iostream>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <fstream>
#include <cmath>
#include <algorithm>
#include <set>
#include <map>

using namespace std;

int n, m, timer, cc, col;
bool color[200001], ans[200001];
vector<pair<int, int> > edge[200001];
int in_t[200001], ans_t[200001], AnsRes[200001];
map <pair<int, int>, int> res;
vector <int> stackAns;

void cleanStack(int ww, int coll) {
    while (stackAns.back() != ww) {
        AnsRes[stackAns.back()] = coll;
        stackAns.pop_back();
    }
    AnsRes[stackAns.back()] = coll;
    stackAns.pop_back();
}

void dfs(int cur, int parent) {
    int ch = 0;
    color[cur] = true;
    timer++;
    in_t[cur] = timer;
    ans_t[cur] = timer;
    for (int i = 0; i < edge[cur].size(); i++) {
        int cur_t = edge[cur][i].first;
        if (cur_t == parent) {
            continue;
        }
        if (cur_t != parent) {
            if (!color[cur_t]) {
                stackAns.push_back(edge[cur][i].second);
                dfs(cur_t, cur);
                ch++;
                if (ans_t[cur_t] >= in_t[cur]) {
                    col++;
                    int qq = edge[cur][i].second;
                    cleanStack(qq, col);
                }
                if (ans_t[cur_t] < ans_t[cur]) {
                    ans_t[cur] = ans_t[cur_t];
                }
            } else {
                if (ans_t[cur] > in_t[cur_t]) {
                    ans_t[cur] = ans_t[cur_t];
                }
                if (in_t[cur_t] < in_t[cur]) {
                    stackAns.push_back(edge[cur][i].second);
                }
            }
        }
    }

}

void dfs2(int v, int c, int p) {
    color[v] = true;
    for (int i = 0; i < edge[v].size(); i++) {
        int cur_v = edge[v][i].first;
        if (cur_v == p) {
            continue;
        }
        if (!color[cur_v]) {
            if (ans_t[cur_v] >= in_t[v]) {
                cc++;
                res[make_pair((min(v, cur_v)), (max(v, cur_v)))] = cc;
                dfs2(cur_v, cc, v);
            } else {
                res[make_pair((min(v, cur_v)), (max(v, cur_v)))] = c;
                dfs2(cur_v, c, v);
            }
        } else {
            if (in_t[cur_v] <= in_t[v]) {
                res[make_pair((min(v, cur_v)), (max(v, cur_v)))] = c;
            }
        }
    }
}



int main() {
    freopen ("biconv.in", "r", stdin);
    freopen ("biconv.out", "w", stdout);

    cin >> n >> m;

    for (int i = 0; i < m; i++) {
        int b, e;
        cin >> b >> e;
        b--;
        e--;
        edge[b].push_back(make_pair(e, i));
        edge[e].push_back(make_pair(b, i));
    }

    for (int i = 0; i < m; i++) {
        color[i] = false;
    }

    timer = 1;
    int cnt = 0;
    col = 0;

    for (int i = 0; i < n; i++) {
        if (!color[i]) {
            timer = 1;
            dfs(i, -1);
        }
    }

    for (int i = 0; i < n; i++) {
        if (ans[i]) {
            cnt++;
        }
    }

    for (int i = 0; i < m; i++) {
        color[i] = false;
    }

    cc = 0;

    for (int i = 0; i < n; i++) {
        if(!color[i]) {
            dfs2(i, -1, -1);
        }
    }

    cout << col << endl;
    for (int i = 0; i < m; i++) {
        cout << AnsRes[i] << " ";
    }

    return 0;
}