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

//#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;

struct SOpinion
{
	uint m_opinionGiverIdx;
	uint m_opinionTargetIdx;
};

struct SWorkerInfo
{
	SWorkerInfo() : m_bossIdx( -1 ), m_negativesCount( 0 ), m_positivesCount( 0 ) {}

	int m_bossIdx;
	uint m_negativesCount; // how many negative opinions this worker GOT.
	uint m_positivesCount; // how many positive opinions this worker GAVE.
};

typedef std::vector< SWorkerInfo > TWorkers;
typedef std::vector< SOpinion > TOpinions;

class Hierarchy
{
public:
	static const uint BOSS_IDX = 0;

	void Setup( uint maxWorkers, uint opinionCount )
	{
		m_workers.resize( maxWorkers + 1 ); // 0 idx is a dummy idx, it is easier to work input data.
		m_negativeOpinions.reserve( opinionCount / 2 );
		m_postiveOpinions.reserve( opinionCount / 2 );
	}

	void AddNegativeOpinion( uint giverIdx, uint targetIdx )
	{
		m_negativeOpinions.push_back( SOpinion{ giverIdx, targetIdx } );
		AddWokerOpinion( targetIdx, false );
	}

	void AddPositiveOpinion( uint giverIdx, uint targetIdx )
	{
		m_postiveOpinions.push_back( SOpinion{ giverIdx, targetIdx } );
		AddWokerOpinion( giverIdx, true );
	}

	bool FindAndSetDirector()
	{
		int dirIdx = -1;
		const uint size = m_workers.size();
		for( uint i = 1; i < size; ++i )
		{
			uint opinions = m_workers[ i ].m_negativesCount + m_workers[ i ].m_positivesCount;
			if( opinions == 0 )
			{
				dirIdx = i;
				break;
			}
		}

		if( dirIdx > 0 )
		{
			for( uint i = 1; i < size; ++i )
			{
				m_workers[ i ].m_bossIdx = dirIdx;
			}

			m_workers[ dirIdx ].m_bossIdx = BOSS_IDX;
			return true;
		}

		return false;
	}

	bool TryToBuildHierarchy()
	{
		bool succes = ProcessPositives();

		if( !succes )
			return false;

		return ProcessNegatives();
	}

	void PrintHierarchy()
	{
		const uint size = m_workers.size();
		for( uint i = 1; i < size; ++i )
		{
			std::cout << m_workers[ i ].m_bossIdx << "\n";
		}
	}

private:
	void AddWokerOpinion( uint workerIdx, bool isPositive )
	{
		isPositive ? ++m_workers[ workerIdx ].m_positivesCount : ++m_workers[ workerIdx ].m_negativesCount;
	}
	bool ProcessPositives()
	{
		for( const auto& positive : m_postiveOpinions )
		{
			if( !IsBoss( positive.m_opinionGiverIdx, positive.m_opinionTargetIdx, m_workers.size() ) )
			{
				m_workers[ positive.m_opinionGiverIdx ].m_bossIdx = positive.m_opinionTargetIdx;

				bool hasCycle = !IsBoss( positive.m_opinionGiverIdx, BOSS_IDX, m_workers.size() );

				if( hasCycle )
					return false;
			}
		}

		return true;
	}

	bool ProcessNegatives()
	{
		for( const auto& negative : m_negativeOpinions )
		{
			if( IsBoss( negative.m_opinionGiverIdx, negative.m_opinionTargetIdx, m_workers.size() ) )
			{
				// Initially every worker has only a director as a boss, it can be only changed by positive opinion,
				// so we have a collision.
				return false;
			}
		}

		return true;
	}

	bool IsBoss( uint workerIdx, uint potentialBossIdx, uint maxIterations )
	{
		uint currIdx = workerIdx;
		uint i = 0;
		do
		{
			uint workerBoss = m_workers[ currIdx ].m_bossIdx;
			if( workerBoss == potentialBossIdx )
				return true;

			if( workerBoss == -1 || workerBoss == BOSS_IDX )
				return false;

			currIdx = workerBoss;
			++i;

		} while( i < maxIterations );

		return false;

	}

	TWorkers m_workers;
	TOpinions m_negativeOpinions;
	TOpinions m_postiveOpinions;
};

void TestAll()
{
}

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

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

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

	Hierarchy hierarchy;
	hierarchy.Setup( numOfWorkers, numOfOpinions );

	for( uint i = 0; i < numOfOpinions; ++i )
	{
		uint opinionGiverIdx = 0;
		std::cin >> opinionGiverIdx;

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

		char opinionType = 0;
		std::cin >> opinionType;

		if( opinionType == 'T' )
			hierarchy.AddPositiveOpinion( opinionGiverIdx, opinionTargetIdx );
		else
			hierarchy.AddNegativeOpinion( opinionGiverIdx, opinionTargetIdx );
	}

	if( hierarchy.FindAndSetDirector() && hierarchy.TryToBuildHierarchy() )
	{
		hierarchy.PrintHierarchy();
	}
	else
	{
		std::cout << "NIE";
	}

	return 0;
}