// Szeregowanie zadań

#include <stdio.h>
//#include <conio.h> //////////////////////////////////////////////////////////////////////////////////////

long liston[4][103];
long n_zad,m_proc,uzyte_proc,czas=0,kolejny_stop;
char cc;
long zadania[103][4];

long poczatki[103][3];
long wskaz_pocz;

long zostalo[103];

long wskaz_pom,nr_proc_pom;
long wskaz_lista,pierwszy_lista,ostatni_lista;

long lista[4][103];

int main()
{
scanf("%ld %ld",&n_zad,&m_proc);
for (int i=1; i<=n_zad; i++) scanf("%ld %ld %ld",&zadania[i][1],&zadania[i][2],&zadania[i][3]);

/*
FILE *plik;
//plik=fopen("test_00.in","r"); // Odp: TAK
//plik=fopen("test_01.in","r"); // Odp: NIE
//plik=fopen("test_02.in","r"); // Odp: TAK
//plik=fopen("test_03.in","r"); // Odp: TAK
//plik=fopen("test_04.in","r"); // Odp: NIE
//plik=fopen("testy/1.in","r"); // Odp: TAK
//plik=fopen("testy/2.in","r"); // Odp: TAK
//plik=fopen("testy/3.in","r"); // Odp: TAK
//plik=fopen("testy/4.in","r"); // Odp: TAK
//plik=fopen("testy/5.in","r"); // Odp: TAK
//plik=fopen("testy/6.in","r"); // Odp:     TAK
//plik=fopen("testy/7.in","r"); // Odp: TAK
//plik=fopen("testy/8.in","r"); // Odp: TAK
//plik=fopen("testy/9.in","r"); // Odp:     TAK
//plik=fopen("testy/10.in","r"); // Odp: TAK
//plik=fopen("testy/11.in","r"); // Odp: NIE
//plik=fopen("testy/12.in","r"); // Odp: NIE
//plik=fopen("testy/13.in","r"); // Odp: NIE
//plik=fopen("testy/14.in","r"); // Odp: NIE
//plik=fopen("testy/15.in","r"); // Odp: NIE
//plik=fopen("testy/16.in","r"); // Odp: NIE
//plik=fopen("testy/17.in","r"); // Odp: NIE
//plik=fopen("testy/18.in","r"); // Odp: NIE
//plik=fopen("testy/19.in","r"); // Odp: NIE
//plik=fopen("testy/20.in","r"); // Odp: NIE

fscanf(plik,"%ld %ld",&n_zad,&m_proc);
for (int i=1; i<=n_zad; i++) fscanf(plik,"%ld %ld %ld",&zadania[i][1],&zadania[i][2],&zadania[i][3]);
fclose(plik);
*/


int minn,minn2,minn_ind,pom;
// Uszeregowanie wg czasu zakończenia
for (int i=1;i<n_zad; i++)
   {
   minn=zadania[i][2];
   minn_ind=i;
   for (int j=i+1; j<=n_zad; j++) 
      {
      if (zadania[j][2]<minn)
         {
         minn=zadania[j][2];
         minn_ind=j;
         }
      }
   if (minn_ind!=i)
      {
      pom=zadania[i][1];
      zadania[i][1]=zadania[minn_ind][1];
      zadania[minn_ind][1]=pom;
      pom=zadania[i][2];
      zadania[i][2]=zadania[minn_ind][2];
      zadania[minn_ind][2]=pom;
      pom=zadania[i][3];
      zadania[i][3]=zadania[minn_ind][3];
      zadania[minn_ind][3]=pom;
      }
   }

//for (int i=1; i<=n_zad; i++) printf("%ld %ld %ld\n",zadania[i][1],zadania[i][2],zadania[i][3]);

for (int i=1; i<=n_zad; i++) 
   {
   poczatki[i][2]=zadania[i][2];
   poczatki[i][1]=zadania[i][1];
   poczatki[i][0]=i;
   zostalo[i]=zadania[i][3];
   }

for (int i=1;i<n_zad; i++)
   {
   minn=poczatki[i][1];
   minn2=poczatki[i][2];
   minn_ind=i;
   for (int j=i+1; j<=n_zad; j++) 
      {
      if ((poczatki[j][1]<minn) || ((poczatki[j][1]==minn) && (poczatki[j][2]<minn2)))
         {
         minn2=poczatki[j][2];
         minn=poczatki[j][1];
         minn_ind=j;
         }
      }
   if (minn_ind!=i)
      {
      pom=poczatki[i][2];
      poczatki[i][2]=poczatki[minn_ind][2];
      poczatki[minn_ind][2]=pom;
      pom=poczatki[i][1];
      poczatki[i][1]=poczatki[minn_ind][1];
      poczatki[minn_ind][1]=pom;
      pom=poczatki[i][0];
      poczatki[i][0]=poczatki[minn_ind][0];
      poczatki[minn_ind][0]=pom;
      }
   }


uzyte_proc=0;
czas=poczatki[1][1];
wskaz_pocz=1;

while ((wskaz_pocz<=n_zad) && (poczatki[wskaz_pocz][1]==czas)) wskaz_pocz++;
//Teraz 'wskaz_pocz' pokazuje na kolejny czas, w którym zadanie będzie mogło się zacząć

//Dodanie procesów do listy:
wskaz_lista=0;
for (int i=1; i<wskaz_pocz; i++) 
   {
//	printf("1) liston[4][1]=%ld\n",liston[4][1]);///////////////////////////////////////////////////////
	wskaz_lista++;
   if (wskaz_lista==1)
	   {
//	   printf("PIERWSZE\n");///////////////////////////////////////////////////////////////////////////
//	   printf("wskaz_lista=%ld\n",wskaz_lista);/////////////////////////////////////////////////////////
		liston[1][wskaz_lista]=-1;
		liston[2][wskaz_lista]=poczatki[i][0];
		liston[3][wskaz_lista]=wskaz_lista;
		liston[4][wskaz_lista]=-1;
//		printf("2) liston[4][1]=%ld\n",liston[4][1]);///////////////////////////////////////////////////////
				
//      printf("2.3) liston[4][1]=%ld\n",liston[4][1]);///////////////////////////////////////////////////////
		ostatni_lista=wskaz_lista;
//      printf("2.6) liston[4][1]=%ld\n",liston[4][1]);///////////////////////////////////////////////////////
		pierwszy_lista=wskaz_lista;
//      printf("3) liston[4][1]=%ld\n",liston[4][1]);///////////////////////////////////////////////////////
		}
   else 
	   {
//	   printf("drugie\n");///////////////////////////////////////////////////////////////////////////
		liston[1][wskaz_lista]=ostatni_lista;
		liston[2][wskaz_lista]=poczatki[i][0];
		liston[3][wskaz_lista]=wskaz_lista;
		liston[4][wskaz_lista]=-1;
		
		liston[4][ostatni_lista]=wskaz_lista;
		ostatni_lista=wskaz_lista;
		}
// printf("4) liston[4][1]=%ld\n",liston[4][1]);///////////////////////////////////////////////////////
   }

//printf("5) liston[4][1]=%ld\n",liston[4][1]);///////////////////////////////////////////////////////
//lista[4][1]=-1;


//printf("\nLista przed sortowaniem:\npierwszy_lista=%ld\n",pierwszy_lista);
//for (int i=1; i<=wskaz_lista; i++) printf("%ld< [%ld] >%ld\n",liston[1][i],liston[2][i],liston[4][i]);

//Posortowanie wg wolnego czasu:
int byl_ruch=1;
while (byl_ruch)
   {
//   printf("Tu tez\n");
//   printf("Sortuj.\n");
   byl_ruch=0;
   wskaz_pom=pierwszy_lista;
//   printf("wskaz_pom=%ld",wskaz_pom);
//   printf("liston[4][wskaz_pom]=%ld\n",liston[4][wskaz_pom]);
//   scanf("%c",cc);
   while ((wskaz_pom!=-1) && (liston[4][wskaz_pom]!=-1))
      {
      //printf("Weszlo\n");
      // Jeśli ZAPAS kolejnego jest mniejszy niż zapas bieżącego
      // ZAPAS = zakończenie - zostalo - czas
      if ( zadania[ liston[2][wskaz_pom] ][2] - zostalo[ liston[2][wskaz_pom] ] - czas  >  zadania[ liston[2][ liston[4][wskaz_pom] ] ][2] - zostalo[ liston[2][ liston[4][wskaz_pom] ] ] - czas )
         {
//         printf("Chce zamienic %ld i %ld",wskaz_pom,liston[4][wskaz_pom]);
         //No to trzeba zamienić kolejnością te dwa procesy:
         int pom_i=liston[4][wskaz_pom]; // to jest miejsce kolejnego
         
         //Trzeba też podmienić ich dwa graniczne:
         if ( liston[1][wskaz_pom] != -1 )
            {// Jeśli ten na skraju po lewej istnieje
            liston[4][ liston[1][wskaz_pom] ] = pom_i;
            }
         else
            {// Czyli podmieniam z pierwszym:
            pierwszy_lista=pom_i;
            }
         if ( liston[4][pom_i] != -1 )
            {// Jeśli ten na skraju po prawej istnieje
            liston[1][ liston[4][pom_i] ] = wskaz_pom;
            }
         else
            {// Zamieniam z ostatnim:
            ostatni_lista=wskaz_pom;
            }
         
         liston[1][ pom_i ]=  liston[1][wskaz_pom];
         
         liston[1][wskaz_pom]=  liston[4][wskaz_pom];
         liston[4][wskaz_pom]=  liston[4][ pom_i ];
         
         liston[4][ pom_i ]=  wskaz_pom;
         
         
         //No i cofam, bo za chwilę przesunę go do przodu:
         wskaz_pom=pom_i;
         
         byl_ruch=1;
//         printf("\nW srodku, po zamianie:\n");
//			for (int i=1; i<=wskaz_lista; i++) printf("%ld< [%ld] >%ld\n",liston[1][i],liston[2][i],liston[4][i]);
         }
      
      wskaz_pom = liston[4][wskaz_pom];
      }
   }


//printf("\nLista po sortowaniu:\npierwszy_lista=%ld\n",pierwszy_lista);
//for (int i=1; i<=wskaz_lista; i++) printf("%ld< [%ld] >%ld\n",liston[1][i],liston[2][i],liston[4][i]);

// Mam wszystko przygotowane do rozpoczęcia symulacji.
int stop=0;
while (!stop)
   {
//   printf("\n\n\nNa poczatku petli sprawa wyglada tak:\nObecny czas to: %ld\nZadania na liscie to: ",czas);
//   wskaz_pom=pierwszy_lista;
//   while (wskaz_pom!=-1)
//      {
//      printf("%ld ",liston[2][wskaz_pom]);
//      wskaz_pom = liston[4][wskaz_pom];
//      }
//   printf("\nA kolejnym zadaniom zostalo tyle czasu:\n");
//   for (int i=1; i<=n_zad; i++) printf("zad[%ld] => %ld\n",i,zostalo[i]);
//   printf("\n");
   
   
   kolejny_stop=1000001;
   // Najpierw muszę określić, do jakiego czasu nic się nie będzie zmieniać.
   // W tym celu porównuję czasy do zakończenia działających procesów oraz czas rozpoczęcia kolejnego.
   if (wskaz_pocz<=n_zad) kolejny_stop=poczatki[wskaz_pocz][1];
   // 'lista' jest uszeregowana wg czasu skończenia, więc wystarczy porównać z tą jedną wartością.
   //if ((pierwszy_lista!=-1) && (kolejny_stop > czas + zostalo[liston[2][pierwszy_lista]]))   kolejny_stop = czas + zostalo[liston[2][pierwszy_lista]];
   // NIE!!!!!!!!!!!! Nie można tak, bo to jest wg czasu "koniecznego" skończenia, a równie dobrze może kolejne zadanie MÓC skończyć się później, ale być znacznie krótsze.
   //Trzeba będzie sprawdzić całą listę lub do liczby procesorów.
   
	
	wskaz_pom=pierwszy_lista;
   nr_proc_pom=1;
//   printf("6.5) liston[4][1]=%ld\n",liston[4][1]);///////////////////////////////////////////////////////
   
   while ((nr_proc_pom<=m_proc) && (wskaz_pom!=-1))
      {
//      printf("7) liston[4][1]=%ld\n",liston[4][1]);///////////////////////////////////////////////////////
      if (kolejny_stop > czas + zostalo[ liston[2][wskaz_pom] ]) kolejny_stop = czas + zostalo[ liston[2][wskaz_pom] ];
      
//      printf("8) liston[4][1]=%ld\n",liston[4][1]);///////////////////////////////////////////////////////
      wskaz_pom = liston[4][wskaz_pom];
      nr_proc_pom++;
      }
   
//   printf("Lista:\n");
//   for (int i=1; i<=wskaz_lista; i++) printf("%ld< [%ld] >%ld\n",liston[1][i],liston[2][i],liston[4][i]);
//   printf("kolejny_stop==%ld\n\n",kolejny_stop);
   
   
   if (kolejny_stop==1000001) 
      {
      //Czyli już nic nie zostało. Skoro po drodze nie wyrzuciło, to znaczy, że wszystko jest w porządku.
      printf("TAK\n");
      stop=1;
      return 0;
      }
   
   // Ok, skoro już znam kolejny moment czasu, to teraz trzeba po pierwsze zaktualizować wartości zadań - ile zostało
   
   wskaz_pom=pierwszy_lista;
   nr_proc_pom=1;
   while ((nr_proc_pom<=m_proc) && (wskaz_pom!=-1))
      {
      //printf("Odejmuje %ld od 'zadania' %ld\n",kolejny_stop-czas,liston[2][wskaz_pom]);
      zostalo[ liston[2][wskaz_pom] ]-=kolejny_stop-czas;
      if (zostalo[ liston[2][wskaz_pom] ] <= 0)
         {
         //Sprawdzam, czy na pewno proces skończył się w zadanym czasie
         if (zadania[ liston[2][wskaz_pom] ][2] < kolejny_stop)
            {
            // To znaczy, że nie skończyło się w zadanym czasie, a więc ...
            printf("NIE\n");
            stop=1;
            return 0;
            }
         
         // Trzeba zaktualizować listę
         if (( liston[1][wskaz_pom]==-1 ) && ( liston[4][wskaz_pom]==-1 ))
            {
//            printf("Przypadek 1\n");
            pierwszy_lista=-1;
            ostatni_lista=-1;
            }
         else if (( liston[1][wskaz_pom]!=-1 ) && ( liston[4][wskaz_pom]==-1 ))
            {
//            printf("Przypadek 2\n");
            liston[4][ liston[1][wskaz_pom] ]=-1;
            ostatni_lista=liston[1][wskaz_pom];
            }
         else if (( liston[1][wskaz_pom]==-1 ) && ( liston[4][wskaz_pom]!=-1 ))
            {
//            printf("Przypadek 3\n");
            liston[1][ liston[4][wskaz_pom] ]=-1;
            pierwszy_lista=liston[4][wskaz_pom];
            }
         else if (( liston[1][wskaz_pom]!=-1 ) && ( liston[4][wskaz_pom]!=-1 ))
            {
//            printf("Przypadek 4\n");
            liston[1][ liston[4][wskaz_pom] ]= liston[1][wskaz_pom] ;
            liston[4][ liston[1][wskaz_pom] ]= liston[4][wskaz_pom] ;
            }
         
         }
      
      // Przeskok do kolejnego procesu na kolejnym procesorze
      // Co jeśli przed chwilą jakiś proces skasowałem??? Nic, bo wartość kolejnego (w tym wyłączonym procesie) się nie zmieniła
      wskaz_pom = liston[4][wskaz_pom];
      nr_proc_pom++;
      }
   
	//Aktualizuję czas
   czas=kolejny_stop;
   
//   printf("Lista:\n");
//   for (int i=1; i<=wskaz_lista; i++) printf("%ld< [%ld] >%ld\n",liston[1][i],liston[2][i],liston[4][i]);   
//   printf("czas=%ld\n",czas); ////////////////////////////////////////////////////////////////////////////////////////
   
   // Dodać procesy, które się właśnie rozpoczęły
   while (( wskaz_pocz<=n_zad ) && ( poczatki[wskaz_pocz][1]==czas ))
      {
      // Muszę dodać zadanie numer 'poczatki[wskaz_pocz][0]' w taki sposób, aby
      // po lewej w liście było zadanie o wcześniejszym czasie zakończenia, a po prawej z równym lub późniejszym
      
      //Zatem zanim dodam, muszę najpierw wiedzieć, gdzie...
      if (pierwszy_lista==-1)
         {
         // Nie ma jeszcze żadnego
         wskaz_lista++;
         liston[1][wskaz_lista]=-1;
         liston[2][wskaz_lista]=poczatki[wskaz_pocz][0];
         liston[3][wskaz_lista]=wskaz_lista;
         liston[4][wskaz_lista]=-1;
		   
         pierwszy_lista=wskaz_lista;
         ostatni_lista=wskaz_lista;
         }
      else if ( poczatki[wskaz_pocz][2] <= zadania[ liston[2][pierwszy_lista] ][2] )
         {
         // To przypadek, kiedy nowe zadanie musi się skończyć jako pierwsze, a więc ląduje na pierwszym miejscu w liście
         wskaz_lista++;
   		liston[1][wskaz_lista]=-1;
	   	liston[2][wskaz_lista]=poczatki[wskaz_pocz][0];
		   liston[3][wskaz_lista]=wskaz_lista;
		   liston[4][wskaz_lista]=pierwszy_lista;
		   
		   liston[1][pierwszy_lista]=wskaz_lista;
   		pierwszy_lista=wskaz_lista;
         }
      else
         {
         // No a w tym przypadku trzeba wyszukać tego miejsca...
         wskaz_pom=pierwszy_lista;
         while (( liston[4][wskaz_pom]!=-1 ) && ( poczatki[wskaz_pocz][2]  >  zadania[ liston[2][ liston[4][wskaz_pom] ] ][2]  ))
            {// Szukam miejsca, w którym po prawej będzie zadanie z czasem zakończenia równym lub późniejszym
            wskaz_pom = liston[4][wskaz_pom];
            }
         
         // Mam. Należy dołożyć element na prawo od tego, na który wskazuje 'wskaz_pom'
         if (liston[4][wskaz_pom]==-1)
            {// Wkładam proces na ostatnie miejsce w kolejce
            wskaz_lista++;
            liston[1][wskaz_lista]=wskaz_pom;
            liston[2][wskaz_lista]=poczatki[wskaz_pocz][0];
            liston[3][wskaz_lista]=wskaz_lista;
            liston[4][wskaz_lista]=-1;
            
            liston[4][wskaz_pom]=wskaz_lista;
            ostatni_lista=wskaz_lista;
            }
         else
            {// Wkładam proces do środka
            wskaz_lista++;
            liston[1][wskaz_lista]=wskaz_pom;
            liston[2][wskaz_lista]=poczatki[wskaz_pocz][0];
            liston[3][wskaz_lista]=wskaz_lista;
            liston[4][wskaz_lista]=liston[4][wskaz_pom];
            
            liston[1][ liston[4][wskaz_pom] ] = wskaz_lista;
            liston[4][wskaz_pom]=wskaz_lista;
            }
         
         }
      
      //A tu powinienem coś inkrementować? 
      wskaz_pocz++;
      }
   // Tutaj już wszystkie rozpoczęte teraz procesy są w liście.
   
   
//   printf("\nLista przed sortowaniem:\npierwszy_lista=%ld\n",pierwszy_lista);
//   for (int i=1; i<=wskaz_lista; i++) printf("%ld< [%ld] >%ld\n",liston[1][i],liston[2][i],liston[4][i]);
   
   //Posortowanie wg wolnego czasu:
   int byl_ruch=1;
   while (byl_ruch)
      {
//      printf("Sortuj.\n");
      byl_ruch=0;
      wskaz_pom=pierwszy_lista;
      while ((wskaz_pom!=-1) && (liston[4][wskaz_pom]!=-1))
         {
         // Jeśli ZAPAS kolejnego jest mniejszy niż zapas bieżącego
         // ZAPAS = zakończenie - zostalo - czas
         if ( zadania[ liston[2][wskaz_pom] ][2] - zostalo[ liston[2][wskaz_pom] ] - czas  >  zadania[ liston[2][ liston[4][wskaz_pom] ] ][2] - zostalo[ liston[2][ liston[4][wskaz_pom] ] ] - czas )
            {
//            printf("Chce zamienic %ld i %ld",wskaz_pom,liston[4][wskaz_pom]);
            //No to trzeba zamienić kolejnością te dwa procesy:
            int pom_i=liston[4][wskaz_pom]; // to jest miejsce kolejnego
            
            //Trzeba też podmienić ich dwa graniczne:
            if ( liston[1][wskaz_pom] != -1 )
               {// Jeśli ten na skraju po lewej istnieje
               liston[4][ liston[1][wskaz_pom] ] = pom_i;
               }
            else
               {// Czyli podmieniam z pierwszym:
               pierwszy_lista=pom_i;
               }
            if ( liston[4][pom_i] != -1 )
               {// Jeśli ten na skraju po prawej istnieje
               liston[1][ liston[4][pom_i] ] = wskaz_pom;
               }
            else
               {// Zamieniam z ostatnim:
               ostatni_lista=wskaz_pom;
               }
            
            liston[1][ pom_i ]=  liston[1][wskaz_pom];
            
            liston[1][wskaz_pom]=  liston[4][wskaz_pom];
            liston[4][wskaz_pom]=  liston[4][ pom_i ];
            
            liston[4][ pom_i ]=  wskaz_pom;
            
            
            //No i cofam, bo za chwilę przesunę go do przodu:
            wskaz_pom=pom_i;
            
            byl_ruch=1;
//            printf("\nW srodku, po zamianie:\n");
//			   for (int i=1; i<=wskaz_lista; i++) printf("%ld< [%ld] >%ld\n",liston[1][i],liston[2][i],liston[4][i]);
            }
         
         wskaz_pom = liston[4][wskaz_pom];
         }
      }
   
   
//   printf("\nLista po sortowaniu:\npierwszy_lista=%ld\n",pierwszy_lista);
//   for (int i=1; i<=wskaz_lista; i++) printf("%ld< [%ld] >%ld\n",liston[1][i],liston[2][i],liston[4][i]);
   
   
   // Co teraz? Chyba koniec pętli i przechodzimy do kolejnej chwili czasowej.
   }







return 0;
}