#include <stdio.h>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <string>
#include <queue>
#include <cstdio>
#include <fstream>

using namespace std;

int glbl_counter=0;
int glbl_time_counter=0;
int glbl_eff_cases=0;
int Start_indx=0;
int End_indx=0;

ofstream outputFile("Testing.txt");


struct solution {
char SubmissionState;
int Sol_time;
solution()
{
Sol_time=0;
SubmissionState='Z';
}
};

struct Question
{
int id;
bool Solved;
int NUM_SOL;
int Qtotal_time;
solution sol[30];
Question()
{
NUM_SOL=0;
id=0;
Solved=false;
Qtotal_time=0;
}

public: void Clean_Question()
{
Question();
for(int i=0;i<30;i++)
{
   sol[i].Sol_time=0;
   sol[i].SubmissionState='U';
}

}
};

struct Contest{
Question Q[15];
int id;
bool Defined;
int total_time;
Contest()
{
Defined=false;
total_time=0;
}

public: void Clean_contest()
{
Contest();
for(int i=0;i<15;i++)
{
   Q[i].Clean_Question();
}

}
};

void Solve_Case(Contest CON[]);
void ModifiedselectionSort(int arr[][3],int indx_to_sort_on,int Start_indx,int End_indx);
void selectionSort(int arr[][3],int indx_to_sort_on,int Start_indx,int End_indx);

int main()
{
   Contest contest[105];
   //Read input lines
   string s;
   int NoOfCases;
   char p[30];

   int i1,i0,i2;
   char x[2];
   bool Flag=false;
   bool EXITFLAG=false;

      getline(cin,s);
      NoOfCases=atoi(s.c_str());
      if(NoOfCases==0)
         exit (EXIT_SUCCESS);
      getline(cin,s);
   //Get first line, if empty terminate.
      while(true)
      {
         
      while(true)
      {
         getline (cin, s);
         if(s==""&&Flag)//Case Ends
         {
         //glbl_counter++;
         Flag=false;
         //Solve problem for the previous case before reading new case, and print.
         //Contest *ptr = &(contest);
         Solve_Case(contest);
         for(int i=0;i<101;i++)
         {
         contest[i]=contest[0];
         }
         /*if(glbl_counter>=NoOfCases)
         {
         break;
         }*/
         break;
         }
         copy(s.begin(), s.end(), p);
         p[s.size()]='\0';
         sscanf (p,"%d %d %d %s",&i0,&i1,&i2,x);
         //printf ("%d %d %d %c\n",i0,i1,i2,x[0]);
         if(contest[i0].Defined==false)
            contest[i0].Defined=true;
         contest[i0].id=i0;
         contest[i0].Q[i1].id=i1;
         contest[i0].Q[i1].sol[contest[i0].Q[i1].NUM_SOL].SubmissionState=x[0];
         contest[i0].Q[i1].sol[contest[i0].Q[i1].NUM_SOL].Sol_time=i2;
         contest[i0].Q[i1].Solved=true;
         contest[i0].Q[i1].NUM_SOL++;
         glbl_time_counter++;
         Flag=true;
      }
      NoOfCases--;
      if(NoOfCases==0)
         break;
      else
         {
         cout<<endl;
         outputFile<<endl;
         }
      
      }
      
      return 0;
}


void Solve_Case( Contest CON[])
{
   glbl_eff_cases++;
   int List[105][3];
   int CorrectSequence=0;
   int counter=0;
   int INCORRECT_counter=0;
   int SolvedCounter=0;
   bool flag=false;
   for(int i=0;i<101;i++)
   {
   if(CON[i].Defined)
   
   {
   for(int j=0;j<16;j++)
   {
      if(CON[i].Q[j].Solved)
      {
         for(int k=CON[i].Q[j].NUM_SOL-1;k>=0;k--)
         {
            if(!(CON[i].Q[j].sol[k].SubmissionState=='C'||CON[i].Q[j].sol[k].SubmissionState=='I'))
               continue;
            else{

         if(CON[i].Q[j].sol[k].SubmissionState=='C'&&!flag)
         {
            flag=true;
            CON[i].Q[j].Qtotal_time+=CON[i].Q[j].sol[k].Sol_time;
            CorrectSequence=CON[i].Q[j].sol[k].Sol_time;
            SolvedCounter++;
            continue;
         }
         /*if(CON[i].Q[j].sol[k].SubmissionState=='C'&&flag);
         {
            continue;
         }*/
         if(CON[i].Q[j].sol[k].SubmissionState=='C'&&flag)
         {
            CON[i].Q[j].Qtotal_time+=CON[i].Q[j].sol[k].Sol_time;
            CON[i].Q[j].Qtotal_time-=CorrectSequence;
            CON[i].Q[j].Qtotal_time=CON[i].Q[j].Qtotal_time-20*INCORRECT_counter;
            CorrectSequence=CON[i].Q[j].sol[k].Sol_time;
            INCORRECT_counter=0;
            continue;
         }

         if(CON[i].Q[j].sol[k].SubmissionState=='I'&&flag)
         {
         CON[i].Q[j].Qtotal_time+=20;
         INCORRECT_counter++;
         continue;
         }
            }
         }
      }

      flag=false;
      CON[i].total_time+=CON[i].Q[j].Qtotal_time;
      CorrectSequence=0;
      INCORRECT_counter=0;
   }
      List[counter][0]=CON[i].id;
      List[counter][1]=SolvedCounter;
      List[counter][2]=CON[i].total_time;
      counter++;
      SolvedCounter=0;
   }
   
   }

   //Sorting Phase
   /********************* *********************/
   /********************* *********************/
   /********************* *********************/
   int starting_indx;
   int counter2=0;
   bool flag2=false;
   ModifiedselectionSort(List,1,0,counter);

   int temp_value;
   temp_value=List[Start_indx][1];

   for(int i=Start_indx+1;i<counter+1;i++)
   {
   temp_value=List[i-1][1];
   if(List[i][1]==temp_value)
   {
   End_indx=i;
   counter2++;
   }
   else
   {
      if(counter2>0)
      {
      selectionSort(List,2,Start_indx,End_indx);
      counter2=0;
      }
      Start_indx=i;

   }
   }
   selectionSort(List,2,Start_indx,End_indx);

   Start_indx=0;
   End_indx=0;
   temp_value=List[Start_indx][0];
   for(int i=Start_indx+1;i<counter+1;i++)
   {
   temp_value=List[i-1][2];
   if(List[i][2]==temp_value)
   {
   End_indx=i;
   counter2++;
   }
   else
   {
      if(counter2>0)
      {
      selectionSort(List,0,Start_indx,End_indx);
      counter2=0;
      }
      Start_indx=i;

   }
   }
   selectionSort(List,0,Start_indx,End_indx);
   Start_indx=0;
   End_indx=0;

   /********************* *********************/
   /********************* *********************/
   /********************* *********************/

   for(int i=0;i<counter;i++)
   {
      //if(glbl_eff_cases>0&& i==0)
      //   cout<<endl<<endl;
      
      ////
      //if(i!=counter-1)
      cout<<List[i][0]<<" "<<List[i][1]<<" "<<List[i][2]<<endl;
      outputFile<<List[i][0]<<" "<<List[i][1]<<" "<<List[i][2]<<endl;
      /*else
      {
      cout<<List[i][0]<<" "<<List[i][1]<<" "<<List[i][2];
      glbl_eff_cases++;
      }*/
   }

   /*if(NO_CASES>1)
   {
      cout<<endl;
      outputFile<<endl;
   }*/

   //for(int i=0;i<counter;i++)
   //{
   //   /*if(glbl_eff_cases>1&& i==0)
   //      outputFile<<endl<<endl;
   //   
   //   
   //   if(i!=counter-1)*/
   //   outputFile<<List[i][0]<<" "<<List[i][1]<<" "<<List[i][2]<<endl;
   //   /*else
   //   {
   //   outputFile<<List[i][0]<<" "<<List[i][1]<<" "<<List[i][2];
   //   }
   //   */
   //}
   //if(NO_CASES>1&&glbl_eff_cases!=NO_CASES)
   //   outputFile<<endl;
   //return List;
}


void selectionSort(int arr[][3],int indx_to_sort_on,int Start_indx,int End_indx) {

      int i, j, minIndex, tmp1,tmp2,tmp3;   

      for (i = Start_indx; i < End_indx; i++) {

            minIndex = i;

            for (j = i + 1; j < End_indx+1; j++)

                  if (arr[j][indx_to_sort_on] < arr[minIndex][indx_to_sort_on])

                        minIndex = j;

            if (minIndex != i) {

                  tmp1 = arr[i][0];
              tmp2 = arr[i][1];
              tmp3= arr[i][2];

                  arr[i][0] = arr[minIndex][0];
              arr[i][1] = arr[minIndex][1];
              arr[i][2] = arr[minIndex][2];
                  arr[minIndex][0] = tmp1;
              arr[minIndex][1] = tmp2;
              arr[minIndex][2] = tmp3;

            }

      }

}


void ModifiedselectionSort(int arr[][3],int indx_to_sort_on,int Start_indx,int End_indx) {

      int i, j, minIndex, tmp1,tmp2,tmp3;   

      for (i = Start_indx; i < End_indx; i++) {

            minIndex = i;

            for (j = i + 1; j < End_indx+1; j++)

                  if (arr[j][indx_to_sort_on] > arr[minIndex][indx_to_sort_on])

                        minIndex = j;

            if (minIndex != i) {

                  tmp1 = arr[i][0];
              tmp2 = arr[i][1];
              tmp3= arr[i][2];

                  arr[i][0] = arr[minIndex][0];
              arr[i][1] = arr[minIndex][1];
              arr[i][2] = arr[minIndex][2];
                  arr[minIndex][0] = tmp1;
              arr[minIndex][1] = tmp2;
              arr[minIndex][2] = tmp3;

            }

      }

}