#include <bits/stdc++.h>
#define st first
#define nd second
using namespace std;
const int N = 1e2 + 5; 
pair < pair<int,int>, char> zdarzenia[2*N];
int P[N], K[N], C[N], sztuczneC[N] = {0}; 
int wyznacz_podniesienie(int od_ktorego_indeksu, vector <int> &stan, int dostepne_zbicia, int limit_gorny_zbicia_jednego){
	for (int j = od_ktorego_indeksu; j < stan.size(); ++j){
		int i  = stan[j];
	}
	for (int j = od_ktorego_indeksu; j < stan.size(); ++j){
		int i  = stan[j];
	}
	int mniejsze_lub_rowne = 0;
	for (int pot = 20; pot >= 0; --pot){
		int uzyte_zbicia = 0;
		int strzal = mniejsze_lub_rowne  + (1 << pot);
		if (strzal > limit_gorny_zbicia_jednego)continue;
		int fx = stan[od_ktorego_indeksu];
		int poziom = K[fx] - C[fx] + strzal;
		for (int srijawara = od_ktorego_indeksu; srijawara < stan.size(); ++srijawara){
				int indeks = stan[srijawara];
				if (K[indeks] - sztuczneC[indeks] > poziom){//zawracam
					break;
				}
				else if (K[indeks] - sztuczneC[indeks] < poziom){
					uzyte_zbicia += min(sztuczneC[indeks],min(strzal, poziom - (K[indeks] - sztuczneC[indeks]) ) );
				}
		}
		if (uzyte_zbicia <= dostepne_zbicia){
			mniejsze_lub_rowne = strzal;
		}
	}
	return mniejsze_lub_rowne;
}
bool wykorzystano_zbicia(int limit_gorny_zbicia_jednego, int uzyte_zbicia, int dostepne_zbicia, vector <int> &stan){
	if (uzyte_zbicia == dostepne_zbicia) return 1;
	for (int i : stan){
		if ( sztuczneC[i] > 0 && C[i] - sztuczneC[i] < limit_gorny_zbicia_jednego ){
			return 0;
		}
	}
	return 1;
}
bool fC (const int &a, const int &b){//służy do sortowania
	return K[a] - C[a] < K[b] - C[b];
}
bool fsztuczneC (const int &a, const int &b){//służy do sortowania
	return K[a] - sztuczneC[a] < K[b] - sztuczneC[b];
}

bool fCspr (const int &a, const int &b){//służy do sprawdzania
	return K[a] - C[a] <= K[b] - C[b];
}
bool fsztuczneCspr (const int &a, const int &b){//służy do sprawdzania
	return K[a] - sztuczneC[a] <= K[b] - sztuczneC[b];
}
bool sprawdzenie_posortowaniaC(const vector<int> &a){
	vector <int> b;
	for (int j : a){
		if (C[j] > 0)b.push_back(j);
	}
	bool p = 1;
	for (int i = 0; i + 1 < b.size(); ++i){
		if(!fCspr(b[i], b[i+1])) p = 0;
	}
	return p;
}

bool sprawdzenie_posortowaniasztuczneC(const vector<int> &a){
	vector <int> b;
	for (int j : a){
		if (sztuczneC[j] > 0)b.push_back(j);
	}
	bool p = 1;
	for (int i = 0; i + 1 < b.size(); ++i){
		if(!fsztuczneCspr(b[i], b[i+1])) p = 0;
	}
	return p;
}

int main (){
	ios_base::sync_with_stdio(0);
	int n, m;
	cin >> n >> m;
	for (int i = 0; i < n; ++i){
		cin >> P[i] >> K[i] >> C[i];
	}
	for (int i = 0; i < n; ++i){
		zdarzenia[2*i] = (pair <pair<int,int>, char> (pair <int, int> (P[i],i) , 'p')  );
		zdarzenia[2*i+1] = (pair <pair<int,int>, char> (pair <int, int> (K[i],i) , 'k')  );
	}
	sort (zdarzenia, zdarzenia + 2*n);
	vector <int> stan;

	int poprzedni_czas = 0, liczba_zbic = 0, roznica_czasu = 0, aktualny_czas = 0;
	for (int i = 0; i < 2*n; ++i){
		//for (int i  = 0; i < n; ++i)cerr <<C[i] << ' ';
		sort(stan.begin(), stan.end(), fC);
		assert(sprawdzenie_posortowaniaC (stan));
		aktualny_czas = zdarzenia[i].st.st;
		roznica_czasu = aktualny_czas - poprzedni_czas;
		liczba_zbic = roznica_czasu*m;
		poprzedni_czas = aktualny_czas;
		for (int j = 0; j <= stan.size(); ++j){///to jest liczba
			if (stan.size() == 0)break;
			int uzyte_zbicia = 0;
			for (int i = 0; i < n; ++i){
				sztuczneC[i] = C[i]; 
			}
			for (int srijawara = 0; srijawara < j; ++srijawara){
				int indeks = stan[srijawara];
				if(sztuczneC[indeks] > roznica_czasu){
					sztuczneC[indeks] -= roznica_czasu;
					uzyte_zbicia += roznica_czasu;
				}
				else{
					uzyte_zbicia += sztuczneC[indeks];
					sztuczneC[indeks] = 0; 
				}
			}
			assert(liczba_zbic >= uzyte_zbicia);
			int podniesienie = wyznacz_podniesienie(j, stan, liczba_zbic-uzyte_zbicia, roznica_czasu); // w testach wczytuje podniesienie
			int pierwszy = stan[j];
			int poziom = K[pierwszy] - sztuczneC[pierwszy] + podniesienie;
			for (int srijawara = j; srijawara < stan.size(); ++srijawara){
				int indeks = stan[srijawara];
				if (K[indeks] - sztuczneC[indeks] > poziom){//zawracam
					for (int we = srijawara-1; we>= j; --we){
						int jedyny_sluszny = stan[we];
						if (liczba_zbic > uzyte_zbicia){
							if (sztuczneC[jedyny_sluszny] > 0 &&  C[jedyny_sluszny] - sztuczneC[jedyny_sluszny] < roznica_czasu ){
								++uzyte_zbicia;	///////////////////////////////////////////////////////////////////////////////////////hiper big mistake!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
								--sztuczneC[jedyny_sluszny];
							}
						}
					}
					break;
				}
				else if (K[indeks] - sztuczneC[indeks] < poziom){
					uzyte_zbicia += min(sztuczneC[indeks],min(podniesienie,poziom - (K[indeks] - sztuczneC[indeks]) ) );					
					sztuczneC[indeks] -= min(sztuczneC[indeks],min(podniesienie,poziom - (K[indeks] - sztuczneC[indeks]) ) );
				}
				
				if (srijawara + 1 == stan.size()){//zawracam
					for (int we = srijawara; we>= j; --we){
						int jedyny_sluszny = stan[we];
						if (liczba_zbic > uzyte_zbicia){
							if (sztuczneC[jedyny_sluszny] > 0 &&  C[jedyny_sluszny] - sztuczneC[jedyny_sluszny] < roznica_czasu ){
								++uzyte_zbicia;
								--sztuczneC[jedyny_sluszny];
							}
						}
					}
				}
				
			}
			assert(liczba_zbic >= uzyte_zbicia);
			
			if (sprawdzenie_posortowaniasztuczneC(stan) && wykorzystano_zbicia( roznica_czasu,uzyte_zbicia, liczba_zbic, stan)){
				for (int i = 0; i <n; ++i){
					C[i] = sztuczneC[i];
				}
				break;
			}
			if (j == stan.size())assert(0);
		}
		
		while (i != 2*n - 1 && zdarzenia[i].st.st == zdarzenia[i+1].st.st){
			if (zdarzenia[i].nd == 'p') stan.push_back(zdarzenia[i].st.nd);
			if (zdarzenia[i].nd == 'k'){
				for (int j = 0; j < stan.size(); ++j){
					if (stan[j] == zdarzenia[i].st.nd){
						stan[j] = -1;
					}
				}
			}
			++i;
		}
		if (zdarzenia[i].nd == 'p') stan.push_back(zdarzenia[i].st.nd);
		if (zdarzenia[i].nd == 'k'){
			for (int j = 0; j < stan.size(); ++j){
				if (stan[j] == zdarzenia[i].st.nd){
					stan[j] = -1;
				}
			}
		}
		vector <int> pomoc;
		for (int j : stan){
			if (j >= 0)pomoc.push_back(j);
		}
		stan = pomoc;
	}
	bool do_odp = 1;
	for (int i = 0; i < n; ++i){
		if(C[i] != 0)do_odp = 0;
	}
	if (do_odp)cout <<"TAK\n";
	else cout <<"NIE\n";
	
	
}