#include <bits/stdc++.h>
using namespace std;

#define all(x) begin(x), end(x)
#ifdef CKISEKI
#define safe cerr << __PRETTY_FUNCTION__ << " line " << __LINE__ << " safe\n"
#define debug(a...) debug_(#a, a)
#define orange(a...) orange_(#a, a)
void debug_(auto s, auto ...a) {
  cerr << "\e[1;32m(" << s << ") = (";
  int f = 0;
  (..., (cerr << (f++ ? ", " : "") << a));
  cerr << ")\e[0m\n";
}
#include <experimental/iterator>
void orange_(auto s, auto L, auto R) {
  cerr << "\e[1;33m[ " << s << " ] = [ ";
  using namespace experimental;
  copy(L, R, make_ostream_joiner(cerr, ", "));
  cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define debug(...) safe
#define orange(...) safe
#endif

class SCC {
protected:
  int n, dfc, nscc;
  vector<vector<int>> G;
  vector<int> vis, low, idx, stk;
  void dfs(int i) {
    vis[i] = low[i] = ++dfc;
    stk.push_back(i);
    for (int j : G[i])
      if (!vis[j])
        dfs(j), low[i] = min(low[i], low[j]);
      else if (vis[j] != -1)
        low[i] = min(low[i], vis[j]);
    if (low[i] == vis[i])
      for (idx[i] = nscc++; vis[i] != -1;) {
        int x = stk.back();
        stk.pop_back();
        idx[x] = idx[i]; vis[x] = -1;
      }
  }
public:
  SCC(int n_) : n(n_), dfc(0), nscc(0), G(n), vis(n), low(n), idx(n) {}
  void add_edge(int u, int v) { G[u].push_back(v); }
  void solve() {
    for (int i = 0; i < n; i++) if (!vis[i]) dfs(i);
  }
  int get_id(int x) { return idx[x]; }
  int count() { return nscc; }
};

void solve() {
  int n, q;
  cin >> n >> q;


  const int SZ = n * 3;
  SCC scc(SZ * 3 + q);

  vector<array<int, 2>> es;
  auto add_edge = [&](int l, int r) {
    scc.add_edge(l, r);
    es.push_back({l, r});
  };

  auto gao = [SZ](int l, int r) {
    vector<int> res;
    for (l += SZ, r += SZ; l < r; l >>= 1, r >>= 1) {
      if (l & 1) res.push_back(l++);
      if (r & 1) res.push_back(--r);
    }
    return res;
  };

  vector<int> up(SZ * 2), dn(SZ * 2);
  for (int i = 0; i < SZ; i++)
    up[i + SZ] = dn[i + SZ] = i;
  for (int i = SZ - 1; i > 0; i--) {
    up[i] = i + SZ;
    add_edge(up[i << 1], up[i]);
    add_edge(up[i << 1 | 1], up[i]);
  }
  for (int i = SZ - 1; i > 0; i--) {
    dn[i] = i + SZ * 2;
    add_edge(dn[i], dn[i << 1]);
    add_edge(dn[i], dn[i << 1 | 1]);
  }

  for (int x = 0; x < q; x++) {
    int a, b, c, d;
    cin >> a >> b >> c >> d;
    --a;
    --c;
    
    for (int i : gao(a, b))
      for (int j : gao(c, d)) {
        add_edge(up[i], x + SZ * 3);
        add_edge(x + SZ * 3, dn[j]);
      }
  }

  scc.solve();

  const int m = scc.count();
  vector<vector<int>> S(m);
  vector<vector<int>> g(m);

  for (auto [x, y] : es) {
    x = scc.get_id(x);
    y = scc.get_id(y);
    assert(x >= y);
    if (x != y)
      g[x].emplace_back(y);
  }

  for (int i = 0; i < n * 3; i++) {
    debug(i+1, scc.get_id(i));
    S[scc.get_id(i)].push_back(i);
  }

  vector<int> vis(m);

  vector<int> big(m);
  for (int i = 0; i < m; i++) {
    if (S[i].size() * 3 >= SZ) {
      big.push_back(i);

      vis.assign(m, false);

      vector<int> cur;
      auto dfs = [&](auto self, int u) {
        if (vis[u]) return;
        vis[u] = true;

        for (int z : S[u])
          cur.push_back(z);
        for (int v : g[u]) {
          self(self, v);
        }
      };

      dfs(dfs, i);

      assert(cur.size() * 3 >= SZ);

      orange(all(cur));
      if (cur.size() * 3 <= SZ * 2) {
        string ans(n * 3, 'R');
        for (int x : cur)
          ans[x] = 'F';
        cout << "TAK\n";
        cout << ans << '\n';
        safe;
        debug("take big, OK");
        return;
      }

    }
  }

  vector<int> cant_take(m);

  for (int x : big)
    cant_take[x] = true;

  for (int x = m - 1; x >= 0; x--) {
    for (int y : g[x]) {
      cant_take[x] |= cant_take[y];
    }
  }

  vector<int> cur;
  for (int x = 0; x < m; x++) {
    if (cant_take[x]) continue;
    for (int z : S[x]) {
      cur.push_back(z);
    }
    
    if (cur.size() * 3 >= SZ) {
      assert(cur.size() * 3 <= SZ * 2);
      string ans(n * 3, 'R');
      for (int y : cur)
        ans[y] = 'F';
      cout << "TAK\n";
      cout << ans << '\n';
      orange(all(cur));
      return;
    }
  }

  cout << "NIE\n";
}

int main() {
  cin.tie(nullptr)->sync_with_stdio(false);

  int t;
  cin >> t;
  while (t--)
    solve();

  return 0;
}