#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <sstream>
#include <set>
#include <map>
#include <vector>
#include <list>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <string>
#include <queue>
#include <bitset>		//UWAGA - w czasie kompilacji musi byc znany rozmiar wektora - nie mozna go zmienic
#include <cassert>
#include <iomanip>		//do setprecision
#include <ctime>
#include <complex>
#include <unordered_set>
#include <unordered_map>
using namespace std;

#define FOR(i,b,e) for(int i=(b);i<(e);++i)
#define FORQ(i,b,e) for(int i=(b);i<=(e);++i)
#define FORD(i,b,e) for(int i=(b)-1;i>=(e);--i)
#define REP(x, n) for(int x = 0; x < (n); ++x)

#define ST first
#define ND second
#define PB push_back
#define MP make_pair
#define LL long long
#define ULL unsigned LL
#define LD long double

const double pi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342;

//using namespace std::tr1;

#define MR 1000010

typedef priority_queue<pair<int,int>, vector<pair<int,int>>, greater<pair<int,int>> > kolejka;
typedef map < int, kolejka > mapa;
typedef set < int > zbior;

mapa miotla;

int ans[MR];

pair < int, pair<int,int> > res[MR];

// komparator do sortowania par (nrRezerwacji,czyKoniec)
bool cmp(const pair <int,bool> &p1, const pair <int,bool> &p2)
{
	int v1 = p1.ND ? res[p1.ST].ND.ND : res[p1.ST].ND.ST;
	int v2 = p2.ND ? res[p2.ST].ND.ND : res[p2.ST].ND.ST;
	if(v1 != v2) return v1 < v2;
	if(p1.ND != p2.ND) return p1.ND < p2.ND;
	// jako ostatnie kryterium wez pod uwage nr przyrzadu
	return res[p1.ST].ST < res[p2.ST].ST;
}

// komparator do posortowania nr rezerwacji po poczatkach
bool cmpN(const int &x, const int &y)
{
	return res[x].ND.ST < res[y].ND.ST;
}

pair <int, bool > zdarzenia[2*MR];

//pair < int, int > spr[MR];
//set < int > spr1;

struct rezerwacja	//struktura do kopcow skosnych
{
	int left, right;
	pair < int, int > key;
}t[MR];

int merge(int a, int b)		//zlacz 2 kopce a, b
{
	if(a == -1)
		return b;
	else if(b == -1)
		return a;	
	if(t[a].key < t[b].key)
		swap(a, b);
	t[a].right = merge(t[a].right, b);
	swap(t[a].left, t[a].right);
	return a;
}//merge
void insert(int &r, int x)	//dolacz rezerwacje x do kopca r
{
	r = merge(r, x);
}//insert
pair < int, int > extractMax(int &r)
{
	pair < int, int > mx = t[r].key;	
	r = merge(t[r].left, t[r].right);
	return mx;
}//extracMax

int wsk[MR];	// wskazniki na korzenie kopcow
pair < pair < int, int >, int > tsort[MR];

int main()
{
	int n, k;
	scanf("%d%d", &n, &k);
	REP(i,n) scanf("%d%d%d", &res[i].ND.ST, &res[i].ND.ND, &res[i].ST);

	//REP(i,n) assert(res[i].ND.ND == 999999999);

	//REP(i,n) spr[i] = res[i].ND;

	// modyfikuj czasy zakonczenia rezerwacji
	REP(i,n) tsort[i] = MP(MP(res[i].ST, res[i].ND.ND), i);
	sort(tsort,tsort+n);

	// przygotuj kopce
	REP(i,n)
	{
		t[i].left = t[i].right = -1;
		t[i].key = MP(res[tsort[i].ND].ND.ST, tsort[i].ND);
	}
	REP(i,n)
	{
		wsk[i] = -1;
		insert(wsk[i], i);
	}

	for(int i = 0; i < n;)
	{
		int j = i+1;
		while(j < n && tsort[i].ST.ST == tsort[j].ST.ST) j++;
		// merguj kopce od konca dla tego samego przyrzadu
		int ile = 1;	// poki co mamy tylko ostatnia rezerwacje
		int pom;
		pair < int, int > mx;
		FORD(k,j,i+1)
		{
			// ile mozna skalowac
			int ileS = tsort[k].ST.ND-tsort[k-1].ST.ND;
			ileS = min(ileS, ile);
			pom = 0;
			while(pom < ileS)
			{
				mx = extractMax(wsk[k]);
				res[mx.ND].ND.ND = min(res[mx.ND].ND.ND, tsort[k].ST.ND);
				res[mx.ND].ND.ND -= pom++;
				ile--;
			}
			// merguj
			ile++;
			wsk[k-1] = merge(wsk[k-1], wsk[k]);
		}
		// zobacz czy na koncu cos trzeba przeskalowac
		pom = 0;
		while(ile)
		{
			mx = extractMax(wsk[i]);
			res[mx.ND].ND.ND = min(res[mx.ND].ND.ND, tsort[i].ST.ND);
			res[mx.ND].ND.ND -= pom++;
			ile--;
		}
		i = j;
	}

	// spr czy wszystkie rezerwacje sa ok
	REP(i,n)
		if(res[i].ND.ST > res[i].ND.ND)
		{
			printf("NIE\n");
			return 0;
		}
	/*REP(i,n) spr1.insert(res[i].ND.ND);
	assert(spr1.size() == n);*/
	// wyznacz zdarzenia po zmodyfikowaniu rezerwacji
	int ilee = 0;
	REP(i,n)
	{
		zdarzenia[ilee++] = MP(i,0);
		zdarzenia[ilee++] = MP(i,1);
	}
	sort(zdarzenia, zdarzenia+ilee, cmp);

	//printf("Zaczynam zamiatac\n");

	// zamiataj
	REP(i,ilee)
	{
		//if(i%10000 == 0) printf("Przerabiam zdarzenie %d\n", i);
		if(!zdarzenia[i].ND)
		{
			// poczatek
			// spr czy ten przyrzad jest w miotle i dodaj pare (endRez, nrRez)
			mapa :: iterator it = miotla.find(res[zdarzenia[i].ST].ST);
			if(it == miotla.end())
			{
				// nie ma
				kolejka Q;
				Q.push(MP(res[zdarzenia[i].ST].ND.ND,zdarzenia[i].ST));
				miotla[res[zdarzenia[i].ST].ST] = Q;
			}
			else
			{
				it->ND.push(MP(res[zdarzenia[i].ST].ND.ND,zdarzenia[i].ST));
			}
		}
		else if(!ans[zdarzenia[i].ST])
		{
			// zakonczona nie zamknieta rezerwacja
			// wiecej zabawy, zamknij wszystkie otwarte rezerwacje
			for(mapa :: iterator it = miotla.begin(); it != miotla.end();)
			{
				// usun rezerwacje
				pair < int, int > close = it->ND.top(); it->ND.pop();
				if(it->ND.empty())
				{
					mapa :: iterator it1 = it;
					it1++;
					miotla.erase(it);
					it = it1;
				}
				else it++;
				// przydziel odpowiedz - koniec danej rezerwacji
				//assert(res[close.ND].ND.ST <= res[zdarzenia[i].ST].ND.ND);
				ans[close.ND] = res[zdarzenia[i].ST].ND.ND;
			}
		}
	}
	//assert(miotla.empty());
	// policz ile jest takich samych rezultatow
	zbior Z;
	REP(i,n) Z.insert(ans[i]);
	printf("%d\n", Z.size());
	//REP(i,n)
	//{
	////	assert(res[i].ND.ST == spr[i].ST);
	////	assert(res[i].ND.ND >= spr[i].ST);
	////	assert(res[i].ND.ND <= spr[i].ND);
	////	assert(ans[i] >= spr[i].ST && ans[i] <= spr[i].ND);
	////	assert(ans[i] >= spr[i].ST);
	//	assert(spr[i].ST > 0 && spr[i].ND > 0);
	//}
	REP(i,n) printf("%d\n", ans[i]);
	return 0;
}