// Slow solution for Rummikub (with backtracking)
// Jeannette de Graaf
#include <iostream>
#include <fstream>
using namespace std;


int aantalrij ( bool A[100][4], int index ) {
// aantal true's in rij index
   int tel = 0; int k;
   for ( k = 0; k < 4; k++ )
      if ( A[index][k] )
         tel++;
   return tel;
}

int verticaal ( bool B[100][4] ) {
// bepaalt de maximaal te behalen waarde door alle verticale series 
// ter lengte > 2 uit te leggen
   int rij, k, volgers;
   int som = 0;
   for ( k = 0; k < 4; k++ ) {
      volgers = 0;
      for ( rij = 99; rij >=0; rij-- ) {
         if ( B[rij][k] ){
            volgers++;  // aantal true's achter elkaar
            som+=rij+1;
         } // if
         else  {
            if ((volgers > 0) && (volgers < 3)){
               som -= (rij+2);
               if (volgers > 1)
                  som -= (rij+3);
            } // if
            volgers = 0;
         } // else
      } // for rij 
      if ((volgers > 0) && (volgers < 3)){
          som -= (rij+2);
          if (volgers > 1)
             som -= (rij+3);
      } // if volgers  
   } // for k
   return som; 
}


void terugzetten ( bool A[100][4], bool B[100][4], int rij) {
   for ( int j = 0; j < 4; j++ )
      A[rij][j] = B[rij][j];
}    

void maximaal ( bool kopie[100][4], bool tiles[100][4], int i, int som, int &
maxsom ) {
   // horizontaal backtracken; recursie
   int k;
   if ( i == 100 ) {
      som += verticaal ( kopie );
      if ( som > maxsom )
         maxsom = som;
   }
   else { // i < 100; recursieve aanroepen
      if ( aantalrij (kopie, i) < 3 )  // geen serie
         maximaal( kopie, tiles, i+1, som, maxsom );
      else { 
         if ( aantalrij (kopie, i) == 3 ) { // 2 mogelijkheden
            maximaal ( kopie, tiles, i+1, som, maxsom); 
            for ( k = 0; k < 4; k++) 
               kopie[i][k] = false;
            maximaal (kopie, tiles, i+1, som+3*(i+1), maxsom);   
            terugzetten (kopie, tiles, i); // rij i terugzetten
         } // if 3
         else {  // 4 van een kleur: 6 mogelijkheden
               maximaal ( kopie, tiles, i+1, som, maxsom); 
            
               kopie[i][0] = false;
               kopie[i][1] = false;
               kopie[i][2] = false;
               maximaal (kopie, tiles, i+1, som+3*(i+1), maxsom); 
               kopie[i][2] = true;
            
               kopie[i][3] = false;
               maximaal (kopie, tiles, i+1, som+3*(i+1), maxsom); 
               kopie[i][1] = true;
            
               kopie[i][2] = false;
               maximaal (kopie, tiles, i+1, som+3*(i+1), maxsom); 
               kopie[i][0] = true;
            
               kopie[i][1] = false;
               maximaal (kopie, tiles, i+1, som+3*(i+1), maxsom); 
           
               kopie[i][0] = false;
               maximaal (kopie, tiles, i+1, som+4*(i+1), maxsom); 
               for ( k = 0; k < 4; k++) {
                  kopie[i][k] = true;
               }
         }  // else      
      } 
   } // else recursieve aanroepen
} // maximaal


int main ( ) {

   int teller, i, j, cases;
   bool tiles[100][4];
   bool kopie[100][4];
   // kleuren: 0 <-> g; 1<-> y; 2<-> r; 3 <-> b
   int uitleggen;
   
   int n; // actuele aantal stenen, kan 400 zijn maximaal
   int waarde;
   char kleur;
   
   cin >> cases;
   for ( teller = 0; teller < cases; teller++ ) {
      for ( i = 0; i < 100; i++ )
         for ( j = 0; j < 4; j++ ) 
            tiles[i][j] = false;
      cin >> n;      
      for ( i = 0; i < n; i++ ) {
         cin >> waarde;
         cin >> kleur;
         if (kleur == 'g')
            tiles[waarde-1][0] = true;
         else {
            if (kleur == 'y')
               tiles[waarde-1][1] = true;
            else {
               if (kleur == 'r')
                  tiles[waarde-1][2] = true;
               else
                  tiles[waarde-1][3] = true;
            }
         }
      } // for i: stenen inlezen
      // kopie maken
      for ( i = 0; i < 100; i++ )
         terugzetten (kopie, tiles, i);
         
      uitleggen = 0;
      maximaal(kopie, tiles, 0, 0, uitleggen);
      cout << uitleggen << endl;

   } // for teller
   return 0;
}
