#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef pair<ld, ld> pd;

typedef vector<int> vi;
typedef vector<ld> vd;
typedef vector<ll> vl;
typedef vector<pi> vpi;
typedef vector<pl> vpl;

#define FOR(i, a, b) for (int i = a; i < (b); i++)
#define F0R(i, a) for (int i = 0; i < (a); i++)
#define FORd(i, a, b) for (int i = (b) - 1; i >= (a); i--)
#define F0Rd(i, a) for (int i = (a) - 1; i >= 0; i--)
#define trav(a, x) for (auto &a : x)
#define sz(x) (int)(x).size()
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()
#define ins insert

const char nl = '\n';

// Increase:
// - Change problem to earliest success (could increase n)
// - Make another decrease rank (precompute)
// - Increase n (# that solve > 0 problems (everyone has at least 1 attempt))
//   - Should increase lowest one
//   - If currently have 0, could increase n simultaneously

// Decrease:
// - Change problem from earliest success to fail
//   - This either decreases total (could decrease n)
//   - Or increases penalty

struct Score {
	int score, penalty;
	bool operator<(const Score& o) const {
		if (score != o.score) return score > o.score;
		return penalty < o.penalty;
	}
};
Score operator+(Score a, Score b) {
	return {a.score + b.score, a.penalty + b.penalty};
}

void solve() {
	int M; cin >> M;
	map<string, map<string, vector<pair<int, bool>>>> mp;
	while (M--) {
		string team; cin >> team;
		string prob; cin >> prob;
		int t; cin >> t;
    string s; cin >> s;
		bool p = s == "accepted";

		mp[team][prob].push_back({t, p});

	}

	int n = 0;
	vector<pair<Score, string>> scores;
	map<string, Score> toScore;
  vector<pair<Score, string>> newZeroScores;
	for (const auto& [team, m]: mp) {
		int num = 0;
		int penalty = 0;
		for (auto [_, v]: m) {
			bool got = false;
			int add = 0;
			int num_fail = 0;
			for (auto [t, s]: v) {
				if (s) {
					got = true;
					add += t;
					add += 20 * num_fail;
					break;
				}
				else {
					num_fail++;
				}
			}
			if (got) {
				num++;
				penalty += add;
			}
		}
		if (num > 0) n++;
		scores.push_back({{num, penalty}, team});
		toScore[team] = {num, penalty};
		// cout << team << ": " << num << ' ' << penalty << endl;
    
    // if have zero, add to zero scores
    if (num == 0) {
      int maxPenalty = 0;
      for (auto [_, v]: m) {
        maxPenalty = max(maxPenalty, v.back().first + 20 * (sz(v) - 1));
      }
      newZeroScores.push_back({{1, maxPenalty}, team});
    }
	}
	sort(all(scores));
  sort(all(newZeroScores));

  map<string, int> teamToIndex;
  for (int i = 0; i < sz(scores); i++) {
    teamToIndex[scores[i].second] = i;
  }

  vector<Score> justScores;
  for (auto [s, _]: scores) justScores.push_back(s);
	auto getr = [&](Score s) -> int {
		auto it = std::lower_bound(all(justScores), s);
		return distance(justScores.begin(), it);
	};

	int target = min((n + 9) / 10, 35);
	int new_target = min((n + 1 + 9) / 10, 35);
	int new_target_sub = min((n - 1 + 9) / 10, 35);

  // cout << target << ' ' << new_target << ' ' << new_target_sub << nl;

  vector<int> pfx(sz(scores) + 1);
  // get decrease scores
  for (int i = 0; i < sz(scores); i++) {
    auto [score, team] = scores[i];
    auto [num, penalty] = score;
		for (auto [_, v]: mp[team]) {
			int num_fail = 0;

      vector<int> accepts;
			for (auto [t, s]: v) {
				if (s) {
          accepts.push_back(t + 20 * num_fail);
          num_fail++;
          // don't break
				}
				else {
					num_fail++;
				}
			}

      int newScore = num, newPenalty = penalty;
			if (sz(accepts) > 0) {
        if (sz(accepts) == 1) {
          newScore--;
          newPenalty -= accepts[0];
        }
        else {
          // take next accept instead
          newPenalty = penalty - accepts[0] + accepts[1];
        }

        // only consider if doesn't decrease target
        if (newScore > 0 || new_target_sub == target) {
          // cout << "consider: " << team << ' ' << newScore << ' ' << newPenalty << endl;
          int ii = distance(justScores.begin(), upper_bound(all(justScores), score));
          Score ns = {newScore, newPenalty};
          int j = distance(justScores.begin(), upper_bound(all(justScores), ns));
          // [ii, j)
          if (ii < j) {
            pfx[ii]++;
            pfx[j]--;
          }
        }
			}
		}
  }

  FOR(i, 1, sz(pfx)) {
    pfx[i] += pfx[i-1];
  }

	// cout << "target: " << target << ' ' << n << nl;

	map<string, int> canWin;

	for (const auto& [team, m]: mp) {
    auto [score, penalty] = toScore[team];
		canWin[team] = getr(toScore[team]) < target;
		for (auto [_, v]: m) {
			bool got = false;
			int add = 0;
			int num_fail = 0;
			for (auto [t, s]: v) {
				if (s) {
					got = true;
					add += t;
					add += 20 * num_fail;
					break;
				}
				else {
					num_fail++;
				}
			}
      int newScore = score, newPenalty = penalty;
      if (got) {
        newPenalty = penalty - add + v[0].first;
      }
      else {
        newScore++;
        newPenalty += v[0].first;
      }
      if (score == 0 && newScore > 0) {
        canWin[team] |= getr({newScore, newPenalty}) < new_target;
      }
      else {
        canWin[team] |= getr({newScore, newPenalty}) < target;
      }
		}

    // increase somebody else from 0
    for (int i = max(0, sz(newZeroScores) - 2); i < sz(newZeroScores); i++) {
      auto [zScore, zTeam] = newZeroScores[i];
      if (team != zTeam && !(zScore < toScore[team])) {
      // if (team != zTeam && toScore[team] < zScore) {
        canWin[team] |= getr({score, penalty}) < new_target;
      }
    }

    // check if we can decreasing other rank
    if (pfx[teamToIndex[team]] > 0) {
      canWin[team] |= getr(toScore[team]) - 1 < target;
    }
	}

	vector<string> wins;
	for (auto [team, w]: canWin) {
		if (w) wins.push_back(team);
	}
	cout << sz(wins) << nl;
	for (auto s: wins) cout << s << ' ';
	cout << nl;
}

int main() {
	ios_base::sync_with_stdio(0); cin.tie(0);
  int T; cin >> T;
  while (T--) solve();
}