#include <iostream>
#include <fstream>
#include <algorithm>
#include <vector>
#include <cstdlib>
#include <unordered_map>

using namespace std;

#define LEN  30005
//#define LEN 10
int p[LEN] = {0};

/**
 *   Fie fie A un sir: a1 < a2 < a3 < ... < an
 *   Urmatorul algoritm realizeaza o partitie minimina respectand conditia D.
 *   Algoritm:
 *      - P este un sir cu ajutorul caruia punem elemente din A in partitii. Ex:
 *         - marcam ca A[i] este in partitia k punand p[i] = k (i.e. elementul i din A e in paritia k)
 *      - Folosim doi "pointeri" i si j astfel:
 *         - daca A[i] este liber, atunci se deschide o noua partitie "k" pt elementul A[i] (P[i] = k) si
 *           apoi cau tprimul colocatar cu A[i] - adica primul j (i.e. ) a.i: 
 *               -  P[j] este liber 
 *               -  A[j] respecta conditia in raport cu A[i]
 *         - daca A[i] nu este liber atunci caut primul colocatar cu A[i], adica tot primul j (dupa i) a.i
 *               -  P[j] este liber 
 *               -  A[j] respecta conditia in raport cu A[i]
 *            Deci exprimam asta astfel:  P[j] = P[i]
 *     - Dupa ce i parcurge toate valorile de la 1 la n, problema este rezolvata optim.
 */


int main() {

   vector<pair<int, int>> a;
   // pos intiala in a ->  partition number
   unordered_map<int, int> sol;

   ifstream cinfile("partitie.in");
   ofstream coutfile("partitie.out");
   
   int N = 0;
   int D = 0;

   cinfile >> N;
   cinfile >> D;

   a.push_back({0, 0});
   for (int i = 1; i <= N ; i++) {
        int number = 0;
        cinfile >> number;
        a.push_back({number, i});
   }

   sort(a.begin(), a.end());

   int part_num = 0;
   
   int j = 2;
   for (int i = 1; i <= N; i++) {
       if (p[i] == 0) {
          // a[i] este liber
          part_num++;
          p[i] = part_num;

          // inregistreaza in solutia finala
          sol[a[i].second] = part_num;
       }
       
       // caut primul colocatar cu a[i] care e liber si respecta conditia D in raport cu a[i] 
       // Asa dar, sar peste cei care nu respecta conditia de mai sus(luat || nu respecta D).
       while ((j <= N) && (p[j] > 0 || a[j].first < a[i].first + D)) {
          j++;
       }

       if (j <= N) {
          // a[j] devine colocatar cu a[i]
          p[j] = p[i];

          // inregistreaza in solutia finala
          sol[a[j].second] = p[i];
       }
   }


   // display the solution
   coutfile << part_num << endl;
   for (int i = 1; i <= N; i++) {
      coutfile << sol[i] << endl;
   }
}