#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


int gold(int n) {
  return min((n + 10 - 1) / 10, 35);
}

int M;
vector<string> C, P, S;
vector<Int> T;

int main() {
  char buf[110];
  
  for (int numCases; ~scanf("%d", &numCases); ) { for (int caseId = 1; caseId <= numCases; ++caseId) {
    scanf("%d", &M);
    C.resize(M);
    P.resize(M);
    T.resize(M);
    S.resize(M);
    for (int i = 0; i < M; ++i) {
      scanf("%s", buf); C[i] = buf;
      scanf("%s", buf); P[i] = buf;
      scanf("%lld", &T[i]);
      scanf("%s", buf); S[i] = buf;
    }
    
    int N = 0;
    map<string, int> cids;
    for (int i = 0; i < M; ++i) {
      if (!cids.count(C[i])) {
        cids[C[i]] = N++;
      }
    }
    
    vector<vector<int>> iss(N);
    for (int i = 0; i < M; ++i) {
      iss[cids[C[i]]].push_back(i);
    }
    vector<pair<Int, Int>> scores(N, make_pair(0, 0));
    for (int u = 0; u < N; ++u) {
      const auto &is = iss[u];
      map<string, vector<int>> jss;
      for (const int i : is) {
        jss[P[i]].push_back(i);
      }
      for (const auto &kv : jss) {
        Int wa = 0;
        for (const int i : kv.second) {
          if (S[i][0] == 'a') {
            --scores[u].first;
            scores[u].second += (T[i] + wa * 20);
            break;
          } else {
            ++wa;
          }
        }
      }
    }
    
    vector<pair<pair<Int, Int>, int>> sus(N);
    for (int u = 0; u < N; ++u) sus[u] = make_pair(scores[u], u);
    sort(sus.begin(), sus.end());
    
    int n = 0;
    for (int x = 0; x < N; ++x) if (sus[x].first.first) {
      ++n;
    }
    vector<int> ans(N, 0);
    vector<int> cands;
    for (int x = 0, y = 0; x < N; x = y) {
      for (; y < N && sus[x].first == sus[y].first; ++y) {}
      if (x < gold(n)) {
        for (int z = x; z < y; ++z) ans[sus[z].second] = 1;
      } else if (x == gold(n)) {
        for (int z = x; z < y; ++z) cands.push_back(sus[z].second);
      }
    }
#ifdef LOCAL
cerr<<"cids = ";pv(cids.begin(),cids.end());
cerr<<"scores = "<<scores<<endl;
cerr<<"ans = "<<ans<<endl;
cerr<<"cands = "<<cands<<endl;
#endif
    
    for (int u = 0; u < N; ++u) {
      const auto &is = iss[u];
      map<string, vector<int>> jss;
      for (const int i : is) {
        jss[P[i]].push_back(i);
      }
      for (const auto &kv : jss) {
        // (wa, i)
        vector<pair<Int, int>> acs;
        Int wa = 0;
        for (const int i : kv.second) {
          if (S[i][0] == 'a') {
            acs.emplace_back(wa, i);
          } else {
            ++wa;
          }
        }
        wa = 0;
        for (const int i : kv.second) {
          if (S[i][0] == 'a') {
            // AC -> WA
            if (acs[0] == make_pair(wa, i)) {
              int nn = n;
              auto sc = scores[u];
              if (acs.size() == 1) {
                ++sc.first;
                sc.second -= (T[i] + wa * 20);
              } else {
                const int ii = acs[1].second;
                sc.second -= (T[i] + wa * 20);
                sc.second += (T[ii] + (acs[1].first + 1) * 20);
              }
              if (!sc.first) --nn;
              if (gold(n) == gold(nn)) {
                if (cands.size()) {
                  const int v = cands[0];
                  if (scores[u] < scores[v] && scores[v] <= sc) {
                    for (const int w : cands) ans[w] = 1;
                    cands.clear();
                  }
                }
              }
            }
            break;
          } else {
            // WA -> AC
            int nn = n;
            auto sc = scores[u];
            if (!sc.first) ++nn;
            if (acs.size() == 0) {
              --sc.first;
              sc.second += (T[i] + wa * 20);
            } else {
              const int ii = acs[0].second;
              sc.second -= (T[ii] + acs[0].first * 20);
              sc.second += (T[i] + wa * 20);
            }
            const int pos = lower_bound(sus.begin(), sus.end(), make_pair(sc, -1)) - sus.begin();
            if (pos < gold(nn)) {
              ans[u] = 1;
            }
           	if (nn!=n) if (cands.size()) {
              const int v = cands[0];
              int rank = gold(n);
              if (scores[u] < scores[v]) --rank;
              if (sc < scores[v]) ++rank;
              if (rank < gold(nn)) {
                for (const int w : cands) ans[w] = 1;
                cands.clear();
              }
            }
            ++wa;
          }
        }
      }
    }
    
    vector<string> outs;
    for (int i=0;i<M;i++)
    {
    	auto s=C[i];
    	if (ans[cids[s]])
    	{
    		outs.push_back(s);
    		ans[cids[s]]=0;
    	}
    }
    printf("%d\n", (int)outs.size());
    for (int x = 0; x < (int)outs.size(); ++x) {
      if (x) printf(" ");
      printf("%s", outs[x].c_str());
    }
    puts("");
  }
#ifndef LOCAL
  break;
#endif
  }
  return 0;
}