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

#define TRACE(x) cerr << __LINE__ << ": " << #x << " = " << x << endl
#define _ << " _ " <<

template<class> struct is_container : false_type {};
template<class... Ts> struct is_container<vector<Ts...>> : true_type {};
template<class... Ts> struct is_container<map<Ts...>> : true_type {};
template<class... Ts> struct is_container<unordered_map<Ts...>> : true_type {};
template<class... Ts> struct is_container<set<Ts...>> : true_type {};
template<class... Ts> struct is_container<unordered_set<Ts...>> : true_type {};
template<class... Ts> struct is_container<multiset<Ts...>> : true_type {};
template<class... Ts> struct is_container<unordered_multiset<Ts...>> : true_type {};
template<class T, class U>
ostream& operator<<(ostream &o, pair<T, U> x) {
  return o << "(" << x.first << ", " << x.second << ")";
}
template<class T, class = typename enable_if<is_container<T>::value>::type>
ostream& operator<<(ostream &o, T x) {
  int f = 1;
  o << "{";
  for (auto y : x) {
    o << (f ? "" : ", ") << y;
    f = 0;
  }
  return o << "}";
}

#define fi first
#define se second
#define all(x) (x).begin(), (x).end()

typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;

const int NUM_P = 26;
int problem_to_i(char p) { return p - 'A'; }

struct Problem {
    vector<pii> accepted, rejected;
    int penalty;
};

typedef vector<Problem> Team;

struct Submission {
    string c;
    char p;
    int t;
    string s;
};

template<class T>
int count_smaller(const vector<T>& vec, const T& el) {
    return lower_bound(all(vec), el) - vec.begin();
}

int ceil(int a, int b) {
    return (a + b - 1) / b;
}

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

    int t;
    cin >> t;
    while (t--) {
        int m;
        cin >> m;
        vector<Submission> subs(m);
        map<string, Team> teams;
        for (int i = 0; i < m; i++) {
            auto& sub = subs[i];
            cin >> sub.c >> sub.p >> sub.t >> sub.s;

            if (!teams.count(sub.c)) teams[sub.c] = Team(NUM_P);
            auto& team = teams[sub.c];

            if (sub.s[0] == 'a') {
                team[problem_to_i(sub.p)].accepted.push_back({i, sub.t});
            } else {
                team[problem_to_i(sub.p)].rejected.push_back({i, sub.t});
            }
        }

        int teams_that_solved = 0; 
        map<string, pii> scores;
        for (auto& [name, team] : teams) {
            int problems = 0, penalty = 0;
            for (auto& problem : team) {
                if (problem.accepted.empty()) continue;
                problems++;
                int cnt = count_smaller(problem.rejected, problem.accepted[0]);
                problem.penalty = cnt * 20 + problem.accepted[0].se;
                penalty += problem.penalty;
            }
            scores[name] = {-problems, penalty};
            if (problems) teams_that_solved++;
        }

        set<pair<pii, string>> scoreboard;
        for (auto& [name, score] : scores) scoreboard.insert({score, name});

        //TRACE(scoreboard);

        auto candidates = scoreboard;
        set<string> sol;
        for (int i = -1; i < m; i++) {
            pii old_score, new_score;
            if (i != -1) {
                auto& sub = subs[i];
                old_score = scores[sub.c];

                new_score = old_score;
                auto& problem = teams[sub.c][problem_to_i(sub.p)];

                if (sub.s[0] == 'a') {  // accept -> reject
                    if (problem.accepted.size() >= 2) {  // there's another AC
                        if (problem.accepted[0].fi == i) {
                            new_score.se += 20;
                            new_score.se -= sub.t;
                            new_score.se += problem.accepted[1].se;
                        }
                    } else {  // this was the only AC
                        new_score.fi++;  // confusing because it's -problems
                        new_score.se -= problem.penalty;
                    }
                } else { // reject -> accept
                    if (problem.accepted.empty()) {  // wasn't solved previously
                        new_score.fi--;  // confusing because it's -problems
                        new_score.se += count_smaller(problem.rejected, {i, sub.t}) * 20;
                        new_score.se += sub.t;
                    } else {
                        if (i < problem.accepted[0].fi) {  // this AC is earlier
                            new_score.se -= problem.penalty;
                            new_score.se += count_smaller(problem.rejected, {i, sub.t}) * 20;
                            new_score.se += sub.t;
                        }
                    }
                }

                teams_that_solved -= !!old_score.fi;
                teams_that_solved += !!new_score.fi;

                scoreboard.erase({old_score, sub.c});
                scoreboard.insert({new_score, sub.c});
                if (!sol.count(sub.c)) {
                    candidates.erase({old_score, sub.c});
                    candidates.insert({new_score, sub.c});
                }
            }

            int gold_score_position = min({
                    ceil(teams_that_solved, 10), 
                    35, 
                    (int)scoreboard.size()
                }) - 1;
            auto gold_score_it = scoreboard.begin();
            advance(gold_score_it, gold_score_position);
            pii gold_score = gold_score_it->fi;
            //TRACE(gold_score_position _ gold_score _ scoreboard);

            while (!candidates.empty() && candidates.begin()->fi <= gold_score) {
                sol.insert(candidates.begin()->se);
                candidates.erase(candidates.begin());
            }

            if (i != -1) {
                auto& sub = subs[i];

                teams_that_solved -= !!new_score.fi;
                teams_that_solved += !!old_score.fi;

                scoreboard.erase({new_score, sub.c});
                scoreboard.insert({old_score, sub.c});
                if (!sol.count(sub.c)) {
                    candidates.erase({new_score, sub.c});
                    candidates.insert({old_score, sub.c});
                }
            }
        }

        cout << sol.size() << '\n';
        for (auto& s : sol) cout << s << ' ';
        cout << '\n';
    }

    return 0;
}