#include <iostream>
#include <fstream>
#include <vector>
#include <set>
#include <queue>
using namespace std;

vector<int> bfs_(vector<vector<int>>& vertices, int& start){

    queue<int> list_;
    list_.push(start);
    vector<int> passedVerticles(vertices.size());
    passedVerticles[start] = 1;
    while(list_.size()){
        int el = list_.front();
        list_.pop();
        for(int i = 0; i < vertices[el].size(); i++){
            if(passedVerticles[vertices[el][i]] != 0){
                continue;
            }
            list_.push(vertices[el][i]);
            passedVerticles[vertices[el][i]] = 1;
        }
    }

    return passedVerticles;
}
struct out{
    out(int countcomp, vector<int> verticescomp){
        count_comp = countcomp;
        vertices_comp = verticescomp;
    }
    int count_comp;
    vector<int> vertices_comp;
};
out bfs(vector<vector<int>>& vertices){

    vector<int> vertices_comp(vertices.size());
    int count_comp = 0;
    for(int i = 0; i < vertices.size(); i++){
        if(vertices_comp[i] == 0){
            vector<int> list = bfs_(vertices, i);
            for(int j = 0; j < list.size(); j++){
                if(list[j]){
                    vertices_comp[j] = count_comp + 1;
                }
            }
            count_comp++;
        }
    }
    out ot(count_comp, vertices_comp);
    return ot;
}
int main() {
    ifstream inp("components.in");
    ofstream out("components.out");
    vector<int> list_adg;
    int n;
    int m;
    inp >> n >> m;
    set<vector<int>> edges;
    for(int i = 0; i < m; i++){
        int tmp[2];
        inp >> tmp[0] >> tmp[1];
        vector<int> edge;
        edge.push_back(tmp[0]);
        edge.push_back(tmp[1]);
        edges.insert(edge);
    }
    vector<vector<int>> vertices(n);
    for(int i = 0; i < n; i++){
        vector<int> vertices_;
        vertices[i] = vertices_;
    }
    for(int i = 0; i < n; i++){
        for(int j = 0; j < n; j++){
            vector<int> tmp;
            tmp.push_back(i+1);
            tmp.push_back(j+1);
            if(edges.count(tmp) != 0){
                vertices[i].push_back(j);
                vertices[j].push_back(i);
            }
        }
    }
    struct out tmp = bfs(vertices);
    string line = "";
    line += to_string(tmp.count_comp) + "\n";
    for(int i = 0; i < tmp.vertices_comp.size(); i++){
        line += to_string(tmp.vertices_comp[i]) + " ";
    }
    out << line;


    return 0;
}