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

#define rep(i,x) for (int i=0;i<(int)x;i++)
#define fore(i,x) for (auto &i:x)
#define For(i,x) for (int i=1;i<=(int)x;i++)
#define ll long long
#define vi vector<int>
#define pii pair<int,int>

// bigger is better

ostream &operator << (ostream &out,const pii &p){
    out<<"{"<<p.first<<", "<<p.second<<"}";
    return out;
}

bool operator < (const pii &a,const pii &b){
    if (a.first ==b.first){
        return a.second>b.second;
    }else{
        return a.first<b.first;
    }
}

bool operator > (const pii &a,const pii &b){
    if (a.first ==b.first){
        return a.second<b.second;
    }else{
        return a.first>b.first;
    }
}

bool operator <= (const pii &a,const pii &b){
    return a==b || a<b;
}


bool operator >= (const pii &a,const pii &b){
    return a==b || a>b;
}

class Problem{
public:
    vector <pair<int,bool> > submission;
    int ac=0;

    void insert(const int &t,const bool &f){
        ac+=f;
        submission.emplace_back(t,f);
    }
};


class Team{
public:
    string name;
    unordered_map <char,Problem> prob;

    void insert(const char &c, const int &t,const bool &f){
        prob[c].insert(t,f);
    }

    pii now={0,0},good,bad;
    int biggest_plt=0;
    int can_wa=-1;
    int can_ac=-1;
    int opt=0;
    int fail_opt=0;
    bool ok=0;

    void calc(){
        for (auto &pb:prob){
            int fail=0;
            int aced=0;
            int first_ac_plet = -1;
            int first_fail = -1;
            int lst_fail = 0;

            fore(i,pb.second.submission){
                if (i.second==0){
                    fail+=20;
                    if (first_fail == -1) first_fail = i.first;
                    // lst_fail = i.first;
                    lst_fail = max(lst_fail,i.first);
                }else{
                    if (aced==0){
                        now.first++;
                        now.second+=i.first+fail;
                        first_ac_plet = i.first + fail;
                    }else if (aced==1){
                        int val = i.first + fail + 20 - first_ac_plet;
                        fail_opt = max(fail_opt,val);
                    }
                    aced++;
                }
            }

            if (aced == 0) biggest_plt = max(biggest_plt,lst_fail + fail-20);

            if (aced && first_fail!=-1){
                opt=max(opt,first_ac_plet-first_fail);
            }

            if (aced==1){
                if (can_wa==-1 || can_wa>first_ac_plet) can_wa=first_ac_plet;
            }else if (aced==0){
                if (can_ac==-1 || can_ac>first_fail) can_ac=first_fail;
            }
        }
        if (can_ac!=-1){
            good={now.first+1, now.second+can_ac};
        }else{
            good={now.first,now.second-opt};
        }
        if (can_wa!=-1){
            bad={now.first-1, now.second-can_wa};
        }else{
            bad={now.first,now.second-fail_opt};
        }
    }
};


unordered_map <string,Team> team;
vector <Team> t;
pii gold;



bool cmp(const Team& a,const Team&b){
    return a.now>b.now;
}


int vaild_team = 0;

void calc_normal(){
    gold = t[max(min(35,(vaild_team+9)/10)-1, 0)].now;
    int should_g = min(35,(vaild_team+9)/10);
    int real_g=0;
    pii bad={100000,0},silver_head = {0,0};
    
    // cout<<"vaild "<<vaild_team<<endl;
    // cout<<"Gold "<<gold<<endl; 

    fore(i,t){
        // cout<<i.name<<" "<<i.good<<" "<<i.now<<" "<<i.bad<<endl;
        if (i.now>=gold){
            i.ok=1;
            if (i.bad.first!=0) bad=min(bad,i.bad);
            real_g++;
        }else{
            if (i.now.first==0) continue;
            if (silver_head == pii{0,0}) silver_head = i.now;
            if (i.good>=gold || (real_g<=should_g && i.now==silver_head && i.now>=bad)){
                i.ok=1;
            }
        }
    }

}

void calc_plus(){
    int biggest_plt=0;

    fore(i,t){
        if (i.now==pii{0,0} && i.good.first){
            biggest_plt = max(biggest_plt,i.biggest_plt);
        }
    }
    if (biggest_plt==0) return;
    pii new_vaild = {1,biggest_plt};

    // cout<<"nv"<<new_vaild<<endl;
    int vaild_team = ::vaild_team+1;
    gold = t[max(min(35,(vaild_team+9)/10)-1, 0)].now;

    // gold = max(gold,new_vaild);
    if (new_vaild>gold) gold=new_vaild;

    // cout<<"plus Gold "<<gold<<endl; 

    fore(i,t){
        // cout<<i.name<<" "<<i.good<<" "<<i.now<<" "<<i.bad<<endl;
        if (i.now>=gold ){
            i.ok=1;
        }else if (i.now.first==0 && i.good.first) {
            if (i.good>=gold){
                i.ok=1;
            }
        }
    }
}

void calc_minus(){
    bool ok=0;
    gold = t[max(min(35,(vaild_team+9)/10)-1, 0)].now;


    fore(i,t){
        if (i.now>=gold && i.bad==pii{0,0}) ok=1;
    }

    if (!ok) return;

    int vaild_team = ::vaild_team-1;
    gold = t[min((int)t.size(), min(35,(vaild_team+9)/10)+1 )-1].now;
    
    // cout<<"Gold minus"<<gold<<endl; 

    fore(i,t){
        // cout<<i.name<<" "<<i.good<<" "<<i.now<<" "<<i.bad<<endl;
        if (i.now>=gold){
            i.ok=1;
        }
    }
}

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

    team.clear();
    t.resize(0);

    rep(i,n){
        string s;
        char p;
        int t;
        string ac;
        cin>>s>>p>>t>>ac;
        team[s].name=s;
        team[s].insert(p,t,ac=="accepted");
    }


    vaild_team = 0;
    
    for (auto &i:team){
        i.second.calc();
        t.push_back(i.second);
        if (i.second.now.first) vaild_team ++;
    }


    sort(t.begin(),t.end(),cmp);

    calc_normal();
    calc_plus();
    calc_minus();



    vector <string> ans;

    fore(i,t){
        if (i.ok) ans.push_back(i.name);
    }

    cout<<ans.size()<<endl;
    for (auto &i:ans){
        cout<<i<<" ";
    }
    cout<<endl;
}

int main(){
    ios::sync_with_stdio(0);cin.tie(0);
    // freopen("input.txt","r",stdin);
    int T;
    cin>>T;
    while (T--) solve();
    return 0;
}