#include <iostream>
#include <array>
#include <vector>

enum Tipus {
    Holgy  = 0,
    Tigris = 1,
};

struct Tipp {
    int ketrec;
    Tipus tipus;
};

using Nezo = std::array<Tipp, 3>;
using Graf = std::vector<std::vector<int>>;

void teszt_be(std::vector<Nezo> &nezo, int &ketrec_db, std::istream &be = std::cin) {
    int m;
    be >> ketrec_db >> m;

    nezo.resize(m);
    for (auto &akt_nezo : nezo) {
        for (auto &tipp : akt_nezo) {
            char t;
            be >> tipp.ketrec >> t;
            tipp.ketrec--;
            tipp.tipus = t == 'H' ? Holgy : Tigris;
        }
    }
}

bool melysegi(int akt, std::vector<bool> &lattam, const Graf &g) {
    if (lattam[akt]) {
        return true;
    }

    if (lattam[akt ^ 1]) {
        return false;
    }

    lattam[akt] = true;
    for (const auto sz : g[akt]) {
        if (!melysegi(sz, lattam, g)) {
            return false;
        }
    }

    return true;
}

std::vector<Tipus> hozzarendel(const std::vector<Nezo> &nezo, int ketrec_db) {
    const int m = ketrec_db * 2;
    Graf g(m);

    int u;
    for (const auto &n : nezo) {
        u = n[0].ketrec * 2 + (n[0].tipus ^ 1);
        g[u].push_back(n[1].ketrec * 2 + n[1].tipus);
        g[u].push_back(n[2].ketrec * 2 + n[2].tipus);

        u = n[1].ketrec * 2 + (n[1].tipus ^ 1);
        g[u].push_back(n[0].ketrec * 2 + n[0].tipus);
        g[u].push_back(n[2].ketrec * 2 + n[2].tipus);

        u = n[2].ketrec * 2 + (n[2].tipus ^ 1);
        g[u].push_back(n[0].ketrec * 2 + n[0].tipus);
        g[u].push_back(n[1].ketrec * 2 + n[1].tipus);
    }

    std::vector<bool> lattam(m), lattam_eredeti(m);
    for (int i = 0; i < m; i += 2) {
        if (!lattam[i] && !lattam[i + 1]) {
            lattam_eredeti = lattam;

            if (!melysegi(i, lattam, g)) {
                lattam = lattam_eredeti;
                if (!melysegi(i + 1, lattam, g)) {
                    return {};
                }
            }
        }
    }

    std::vector<Tipus> ketrec(ketrec_db);
    for (int i = 0, j = 0; i < ketrec_db; i++, j += 2) {
        ketrec[i] = lattam[j] ? Holgy : Tigris;
    }
    return ketrec;
}

bool ellenoriz(const std::vector<Nezo> &nezo, const std::vector<Tipus> &ketrec) {
    for (const auto &n : nezo) {
        int ok = 0;
        for (const auto &t : n) {
            ok += ketrec[t.ketrec] == t.tipus;
        }

        if (ok < 2) {
            return false;
        }
    }

    return true;
}

void feldolgoz(std::istream &be = std::cin) {
    int n;
    be >> n;

    for (int i = 0; i < n; i++) {
        std::vector<Nezo> nezo;
        int ketrec_db;

        teszt_be(nezo, ketrec_db, be);
        const auto ketrec = hozzarendel(nezo, ketrec_db);

        using std::cout;
        
        if (ketrec.empty()) {
            cout << "-1\n";

        } else {
            for (const auto t : ketrec) {
                cout << (t == Holgy ? 'H' : 'T') << ' ';
            }
            cout << '\n';
        }
    }
}

int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    feldolgoz();

    return 0;
}