#include <vector>
#include <math.h>
#include <string>
#include <iostream>
#include <sstream>
#include <limits>
#include <cstring>
#include <array>
#include <algorithm>

//#define PA2016_TEST

#ifdef PA2016_TEST
#define ASSERT( condition ) if ( !( condition ) ) { __debugbreak(); }
#define PAUSE_CONSOLE system( "pause" );
#define DEBUG_ONLY( line ) line;
#else
#define ASSERT( condition )
#define PAUSE_CONSOLE 
#define DEBUG_ONLY( line )
#endif

typedef unsigned int uint;

int Min( int a, int b )
{
	return a < b ? a : b;
}

struct STaskInfo
{
	STaskInfo( uint startTime, uint endTime, uint parts )
		: m_startTime( startTime )
		, m_endTime( endTime )
		, m_parts( parts )
	{}

	uint m_startTime;
	uint m_endTime;
	uint m_parts;
};

struct SPriority
{
	SPriority( double priority, STaskInfo* task )
		: m_priority( priority )
		, m_task( task )
	{
	}

	double m_priority;
	STaskInfo* m_task;
};

struct STimelineEvent
{
	STimelineEvent( uint time, STaskInfo* info, bool isEnd )
		: m_time( time )
		, m_task( info )
		, m_isEnd( isEnd )
	{
	}

	STaskInfo* m_task;
	uint m_time;
	bool m_isEnd;
};

class Scheduler
{
public:
	Scheduler( uint numOfTasks, uint processors ) 
		: m_processors( processors )
	{ 
		m_taskInfos.reserve( numOfTasks );
		m_openTasks.reserve( numOfTasks );
		m_tempPriorities.reserve( numOfTasks );
	}

	void AddTask( uint startTime, uint endTime, uint parts )
	{
		m_taskInfos.push_back( STaskInfo( startTime, endTime, parts ) );
		STaskInfo* info = &m_taskInfos[ m_taskInfos.size() - 1 ];
		AddEvent( info, startTime, false );
		AddEvent( info, endTime - 1, true );
	}

	bool TryToSchedule()
	{
		// Sort timeline:
		std::sort( m_timeline.begin(), m_timeline.end(), []( const STimelineEvent& a, const STimelineEvent& b )
		{
			return a.m_time < b.m_time;
		} );

		uint prevTime = m_timeline[ 0 ].m_time - 1;

		const uint timelineSize = m_timeline.size();
		for( uint i = 0; i < timelineSize; ++i )
		{
			// Process events( add to open task list if needed ):
			uint curr_time = m_timeline[ i ].m_time;
			OnEvent( m_timeline[ i ] );

			bool cont = true;
			for( uint j = i + 1; j < timelineSize; ++j )
			{
				if( m_timeline[ j ].m_time <= curr_time )
				{
					OnEvent( m_timeline[ j ] );
				}
				else
				{
					// We have processed more events, so update outher loop.
					i = j - 1;
					break;
				}
			}

			if( !Schedule( curr_time - prevTime, curr_time ) )
				return false;

			prevTime = curr_time;
		}

		return true;
	}

private:
	bool Schedule( uint timeSlice, uint currTime )
	{
		m_tempPriorities.clear();

		// Calculate priority queue:
		for( auto* task : m_openTasks )
		{
			int priority = CalcPriority( task, currTime, timeSlice );

			if( priority < 0 )
				return false; // Scheduler has failed to schedule task at time.

			m_tempPriorities.push_back( SPriority( priority, task ) );
		}

		// Sort priorites:
		std::sort( m_tempPriorities.begin(), m_tempPriorities.end(), []( const SPriority& a, const SPriority& b )
		{
			return a.m_priority < b.m_priority;
		} );

		GrabTasks( timeSlice );

		RemoveDoneTasksFromOpenList();

		return true;
	}

	void GrabTasks( uint timeslicePerSingleProc )
	{
		int slotsAvailalbeAcrossAllProcessors = timeslicePerSingleProc*m_processors;
		

		for( auto priority : m_tempPriorities )
		{
			uint& taskParts = priority.m_task->m_parts;

			int partsTaken = Min( taskParts, timeslicePerSingleProc );
			taskParts -= partsTaken;

			slotsAvailalbeAcrossAllProcessors -= partsTaken;

			if( slotsAvailalbeAcrossAllProcessors <= 0 )
			{
				// We have reach maximum workload. It is possible that some tasks part cannot
				// be taken, so return them:
				taskParts += -slotsAvailalbeAcrossAllProcessors; 

				return;
			}

		}
	}

	void RemoveDoneTasksFromOpenList()
	{
		uint openTasksSize = m_openTasks.size();
		for( uint i = 0; i < openTasksSize; )
		{
			if( m_openTasks[ i ]->m_parts == 0 )
			{
				m_openTasks[ i ] = m_openTasks[ openTasksSize - 1 ];
				--openTasksSize;
			}
			else
				++i;
		}

		m_openTasks.resize( openTasksSize );
	}

	void AddEvent( STaskInfo* task, uint time, bool isEnd )
	{
		m_timeline.push_back( STimelineEvent( time, task, isEnd ) );
	}

	void OnEvent( const STimelineEvent& event )
	{
		if( !event.m_isEnd )
			m_openTasks.push_back( event.m_task );
	}

	int CalcPriority( const STaskInfo* info, uint currTime, uint timeslice )
	{
		// 0 - biggest priorty;
		auto val = info->m_endTime - info->m_parts - currTime + timeslice - 1;
		return val;
	}

	std::vector< STaskInfo > m_taskInfos;
	std::vector< STimelineEvent > m_timeline;
	std::vector< STaskInfo* > m_openTasks;
	std::vector< SPriority > m_tempPriorities;
	uint m_processors;
};

void TestAll()
{
}

int main()
{
	DEBUG_ONLY( TestAll() );

	uint numOfTasks = 0;
	std::cin >> numOfTasks;

	uint numOfProcessors = 0;
	std::cin >> numOfProcessors;

	Scheduler scheduler( numOfTasks, numOfProcessors );

	for( uint i = 0; i < numOfTasks; ++i )
	{
		uint taskStart = 0;
		std::cin >> taskStart;

		uint taskMaxEnd = 0;
		std::cin >> taskMaxEnd;

		uint taskParts = 0;
		std::cin >> taskParts;

		scheduler.AddTask( taskStart, taskMaxEnd, taskParts );

	}

	if( scheduler.TryToSchedule() )
		std::cout << "TAK";
	else
		std::cout << "NIE";

	return 0;
}