#include<bits/stdc++.h>
using namespace std;
int mian(); int main() { return mian(); }
/*
构造一个长度为 $3n$ 的序列，使得对于任意给定的 $q$ 个 $a_i,b_i,c_i,d_i$，满足以下条件中的一种 
（1）$s_i=0,i\in[a_i,b_i]$ 
（2）$s_i=1,i\in[c_i,d_i]$ 
同时要求至少有 $n$ 个 $0$ 和 $n$ 个 $1$ 
$n\le 33333,q\le 10^5,\sum n\le 333333, \sum q\le 10^6$
$time:30s$，$memory:1G$ 

因为两个限制至少要满足一个，有只需要构造，于是考虑使用 2-sat 
那么每个限制有实现或者不实现，如果直接对于每个限制进行连边，并不好维护在序列上的影响 
所以直接考虑在序列上建边。那么，如果第一个区间中有一个数字是 $1$，就一定会指向第二个区间 中的数字并强制他们全都是 $1$ 
于是可以变为两个区间之间建边。线段树优化建图之后就变为正常 2-sat 
（具体的，因为然亦两个区间中的小区间都要互相连边（只要任意一个成立后面的就要全部得到），因此可以建立一个中间点向两边连边，使得边数为单log） 
会发现只有从 $1$ 推出 $1$ 和从 $0$ 推出 $0$，因此两张图是独立的 
但是有 $n$的限制之后就需要将两张图结合考虑 
对于 tarjan 缩点之后定义每个点的点权为其包含的在序列上点的个数 
那么考虑在一张图上进行操作，假设是在 $1$ 的图上 
那么就要求 $1$ 的点大小必须在 $[n,2n]$ 之间，同时要求点的选择必须形成一个连通块（才能满足推出的性质） 
如果有点的大小 $>2n$，那么明显直接无解，因为一个强联通分量中必须全部相同 
如果所有的点都是 $<=n+1$，那么只要按照顺序一次加，一旦达到范围就停止即可，因此一定有解 
于是就可能存在点的大小在 $(n+1,2n]$ 之间。这样的点至多有 $2$ 个，只需要将其中一个分到 $1$ 中即可 
那么因为只要有一个就一定合法，不妨直接全部取他的前驱。于是只需要判断加起来是否仍然可以继续放下这个点即可 
如果只有一个大点，那么不合法就只需要判断在不选这个点及其后继情况下能选择的个数是否满足范围即可 
如果有两个大点就需要判断至少有一个成立 
总复杂度为 $O(q\log n)$ 
*/
const int N = 1e5 + 15, M = 1e5 + 15, NODE = N * 8 + M;//33333*3=99999
int n, m, cnt_io;

int f_edge[NODE], cnt_edge;
struct edge { int v, net; } eg[M << 6];
void init_edge() { cnt_edge = 0; for(int i = 1; i <= cnt_io; ++i) f_edge[i] = 0; }
void add(const int u, const int v) { eg[++cnt_edge] = (edge) { v, f_edge[u] }; f_edge[u] = cnt_edge; }
#define ls(k) k << 1
#define rs(k) k << 1 | 1
int vit[NODE], rev[N];
int id( const int k, const int i ) { return k + i * ( ( 3 * n ) << 2 ); }
void updata(const int k) {
	add( id( ls(k), 0 ), id( k, 0 ) );
	add( id( rs(k), 0 ), id( k, 0 ) );
	add( id( k, 1 ), id( ls(k), 1 ) );
	add( id( k, 1 ), id( rs(k), 1 ) );
}
void build(const int k, const int l, const int r) {
	if(l == r) return (void) ( cnt_io = max( cnt_io, id(k, 1) ), vit[ id(k, 0) ] = 1, rev[l] = id(k, 0), add( id(k, 0), id(k, 1) ), add( id(k, 1), id(k, 0) ) );
	const int mid = (l + r) >> 1;
	build(ls(k), l, mid); build(rs(k), mid + 1, r);
	updata(k);
}
void Add(const int k, const int l, const int r, const int x, const int y, const int mip, const bool i) {
	if( x <= l and r <= y ) return (void) ( i ? add( mip, id( k, 1 ) ) : add( id( k, 0 ), mip ) );
	const int mid = (l + r) >> 1;
	if( x <= mid ) Add(ls(k), l, mid, x, y, mip, i);
	if( y > mid ) Add(rs(k), mid + 1, r, x, y, mip, i);
}
void ADD(const int l1, const int r1, const int l2, const int r2) {
	Add( 1, 1, 3 * n, l1, r1, ++cnt_io, 0 );
	Add( 1, 1, 3 * n, l2, r2, cnt_io, 1 );
}

int dfn[NODE], low[NODE], tot_dfs;
int col[NODE], cnt_col, val[NODE];
bool instk[NODE];
stack<int> sk;
void dfs_tarjan(const int u) {
	dfn[u] = low[u] = ++tot_dfs;
	sk.push(u); instk[u] = true;
	for(int i = f_edge[u]; i; i = eg[i].net) {
		const int v = eg[i].v;
		if( !dfn[v] ) dfs_tarjan(v), low[u] = min( low[u], low[v] );
		else if( instk[v] ) low[u] = min( low[u], dfn[v] );
	}
	if( dfn[u] == low[u] ) {
		col[u] = ++cnt_col; val[cnt_col] += vit[u];
		while( sk.top() != u ) col[ sk.top() ] = cnt_col, instk[ sk.top() ] = false, val[cnt_col] += vit[ sk.top() ], sk.pop();
		instk[u] = false; sk.pop();
	}
}

vector<int> ep[NODE][2];
int rd[NODE];
bool usd[NODE], inr[NODE];

void init_all() {
	for(int i = 1; i <= cnt_io; ++i) 
		dfn[i] = low[i] = col[i] = vit[i] = rd[i] = rev[i] = val[i] = 0, 
		instk[i] = usd[i] = inr[i] = false,
		ep[i][0].clear(), ep[i][1].clear();
	init_edge();
	tot_dfs = cnt_col = 0;
	cnt_io = 0;
}

void solve() {
	scanf("%d%d", &n, &m);
	init_all();
	build(1, 1, n * 3);//注意n*3 
	for(int i = 1, l1, r1, l2, r2; i <= m; ++i) {
		scanf("%d%d%d%d", &l1, &r1, &l2, &r2);
		ADD(l1, r1, l2, r2);
	}
	for(int i = 1; i <= cnt_io; ++i) if( !dfn[i] ) dfs_tarjan(i);
//	if(n>=3333) exit(0);
	for(int u = 1; u <= cnt_io; ++u) {
		for(int i = f_edge[u]; i; i = eg[i].net) {
			const int v = eg[i].v;
//			cout<<u<<" "<<v<<endl;
			if( col[u] != col[v] ) ep[ col[u] ][0].push_back( col[v] ), ep[ col[v] ][1].push_back( col[u] ), rd[ col[u] ]++;
		}
	}
//	for(int i = 1; i <= cnt_col;++i) for(auto v:ep[i][0]) cout<<i<<" "<<v<<endl;
	vector<int> gen;
	for(int i = 1; i <= cnt_col; ++i) {
		if( val[i] > 2 * n ) { puts("NIE"); return ; }
		if( val[i] > n ) gen.push_back(i);
//		cout<<val[i]<<" ";
	}
	#define DOO \
			q.push( gen.back() ); inr[ gen.back() ] = true;\
			while(!q.empty()) {\
				const int u = q.front(); q.pop();\
				sut += val[u];\
				for(auto v : ep[u][0]) if( !inr[v] ) inr[v] = true, q.push(v);\
			}\
			if(n <= sut and sut <= 2 * n) {\
				puts("TAK");\
				for(int i = 1; i <= 3 * n; ++i) if( inr[ col[ rev[i] ] ] ) putchar('F'); else putchar('R');\
				puts("");\
				break;\
			}
	queue<int> q; 
	int sut = 0; 
/*
2
1 3
1 1 2 2
1 2 3 3
1 1 3 3
1 3
1 1 2 2
2 2 3 3
3 3 1 1
*/
	switch( (int)gen.size() ) {
		case 0 : {
			for(int i = 1; i <= cnt_col; ++i) if(!rd[i]) q.push(i);
			while( !q.empty() ) {
				const int u = q.front(); q.pop();
				sut += val[u]; usd[u] = true;
//				cout<<u<<" ";
				if( sut >= n ) goto OUT1;
				for(auto v : ep[u][1]) { rd[v]--; if(!rd[v]) q.push(v); }
			}
			OUT1:
			puts("TAK");
			for(int i = 1; i <= 3 * n; ++i) if( usd[ col[ rev[i] ] ] ) putchar('F'); else putchar('R');
			puts("");
			break;
		}
		case 1 : {
			DOO;
			sut = 0;
			for(int i = 1; i <= cnt_col; ++i) if(!rd[i] and i != gen.back()) q.push(i);
			while( !q.empty() ) {
				const int u = q.front(); q.pop();
				sut += val[u]; usd[u] = true;
				if( sut >= n ) goto OUT2;
				for(auto v : ep[u][1]) { rd[v]--; if(!rd[v] and v != gen.back()) q.push(v); }
			}
			if( sut < n ) { puts("NIE"); break; }
			OUT2:
			puts("TAK");
			for(int i = 1; i <= 3 * n; ++i) if( usd[ col[ rev[i] ] ] ) putchar('F'); else putchar('R');
			puts("");
			break;
		}
		default: {
			DOO;
			gen.pop_back();
			for(int i = 1; i <= cnt_io; ++i) inr[i] = false;
			sut = 0;
			DOO;
			puts("NIE");
		}
	}
}
int mian() {
	int T; scanf("%d", &T);
	while(T--) solve();
	return 0;
}