After decades of shadowy demonstrations and delays from the game’s maker, Chess 2 has finally been released. You waited in line all night to be one of the first to purchase an example of the hot sequel to the classic original, and now you are finally getting a chance to open up your new investment and take a look inside. What you find is slightly puzzling; in addition to the traditional pieces, the game has been expanded to contain a number of pieces that are not actually original. 
   
  The best-known piece that has been added to the game is the nightrider. The nightrider can make any number of knight moves in a single direction, i.e., its offset from its initial position will be 2*m in one dimension and m in the other for some nonzero integer m. Like other "sliding" pieces, if one of the knight moves would cause it to take another piece it is not able to traverse beyond that point 
   
  The archbishop is also part of Chess 2. The archbishop can simply make any move that a knight or bishop could legally make. 
   
  The strangest new piece is the kraken. The kraken can move to any square on the board, regardless of the position of any other pieces, including its own current position. 
   
  You don't feel like reading the manual to learn about how the new pieces fit into the standard chess opening positions, so instead you place some of the pieces randomly on the board. The game you’ve decided to play is simply to count how many pieces on the board are currently being threatened. A piece is threatened if another piece is able to move into its cell and take it (note that if the kraken moves into its own cell it does not take itself). 
   
  Input 
  Your input file will consist of a single integer N followed by N test cases. Each case will consist of, all separated by whitespace, an integer P followed by the identities and positions of P Chess 2 pieces. Pieces are described by a single character C to denote their type (see specification below) followed by two integers R and F, the 1-based rank and file, respectively, of the piece. 
   
  You've decided to ignore the colors of the pieces in this game. The color of the pieces will not be reflected in the input and so cannot affect your output. 
   
  To make room for the new pieces, the Chess 2 board is a 16 by 16 grid. No specified pieces will fall outside the board, and no two pieces will occupy the same position. 
  

 
  package hackercup.round1; 
   
  import java.io.File; 
  import java.io.FileNotFoundException; 
  import java.io.PrintWriter; 
  import java.util.Scanner; 
   
  public class B { 
   
      public static void main(String[] args) throws FileNotFoundException { 
          Scanner in = new Scanner(new File(B.class.getSimpleName() + ".in")); 
          PrintWriter out = new PrintWriter(new File(B.class.getSimpleName() + ".out")); 
          int T = in.nextInt(); 
          for (int i = 0; i < T; i++) { 
              String s = new B().solve(in); 
              out.println(s); 
              System.out.println(s); 
          } 
          out.close(); 
      } 
   
      private String solve(Scanner in) { 
          int n = in.nextInt(); 
          char[][] a = new char[16][16]; 
          for (int i = 0; i < n; i++) { 
              char c = in.next().charAt(0); 
              int x = in.nextInt() - 1; 
              int y = in.nextInt() - 1; 
              a[x][y] = c; 
          } 
          boolean[][] b = new boolean[16][16]; 
          int[] dx = {-1, 1, 0, 0, -1, -1, 1, 1}; 
          int[] dy = {0, 0, -1, 1, -1, 1, -1, 1}; 
          int[] kdx = {-2, -2, -1, -1, 1, 1, 2, 2}; 
          int[] kdy = {-1, 1, -2, 2, -2, 2, -1, 1}; 
          for (int x = 0; x < 16; x++) { 
              for (int y = 0; y < 16; y++) { 
                  switch (a[x][y]) { 
                      case 'K': 
                          for (int d = 0; d < 8; d++) { 
                              int xx = x + dx[d]; 
                              int yy = y + dy[d]; 
                              if (isValid(xx, yy)) { 
                                  b[xx][yy] = true; 
                              } 
                          } 
                          break; 
                      case 'Q': 
                          for (int d = 0; d < 8; d++) { 
                              int xx = x + dx[d]; 
                              int yy = y + dy[d]; 
                              while (isValid(xx, yy) && a[xx][yy] == 0) { 
                                  xx += dx[d]; 
                                  yy += dy[d]; 
                              } 
                              if (isValid(xx, yy)) { 
                                  b[xx][yy] = true; 
                              } 
                          } 
                          break; 
                      case 'R': 
                          for (int d = 0; d < 4; d++) { 
                              int xx = x + dx[d]; 
                              int yy = y + dy[d]; 
                              while (isValid(xx, yy) && a[xx][yy] == 0) { 
                                  xx += dx[d]; 
                                  yy += dy[d]; 
                              } 
                              if (isValid(xx, yy)) { 
                                  b[xx][yy] = true; 
                              } 
                          } 
                          break; 
                      case 'B': 
                          for (int d = 4; d < 8; d++) { 
                              int xx = x + dx[d]; 
                              int yy = y + dy[d]; 
                              while (isValid(xx, yy) && a[xx][yy] == 0) { 
                                  xx += dx[d]; 
                                  yy += dy[d]; 
                              } 
                              if (isValid(xx, yy)) { 
                                  b[xx][yy] = true; 
                              } 
                          } 
                          break; 
                      case 'N': 
                          for (int d = 0; d < 8; d++) { 
                              int xx = x + kdx[d]; 
                              int yy = y + kdy[d]; 
                              if (isValid(xx, yy)) { 
                                  b[xx][yy] = true; 
                              } 
                          } 
                          break; 
                      case 'S': 
                          for (int d = 0; d < 8; d++) { 
                              int xx = x + kdx[d]; 
                              int yy = y + kdy[d]; 
                              while (isValid(xx, yy) && a[xx][yy] == 0) { 
                                  xx += kdx[d]; 
                                  yy += kdy[d]; 
                              } 
                              if (isValid(xx, yy)) { 
                                  b[xx][yy] = true; 
                              } 
                          } 
                          break; 
                      case 'A': 
                          for (int d = 4; d < 8; d++) { 
                              int xx = x + dx[d]; 
                              int yy = y + dy[d]; 
                              while (isValid(xx, yy) && a[xx][yy] == 0) { 
                                  xx += dx[d]; 
                                  yy += dy[d]; 
                              } 
                              if (isValid(xx, yy)) { 
                                  b[xx][yy] = true; 
                              } 
                          } 
                          for (int d = 0; d < 8; d++) { 
                              int xx = x + kdx[d]; 
                              int yy = y + kdy[d]; 
                              if (isValid(xx, yy)) { 
                                  b[xx][yy] = true; 
                              } 
                          } 
                          break; 
                      case 'E': 
                          for (int xx = 0; xx < 16; xx++) { 
                              for (int yy = 0; yy < 16; yy++) { 
                                  if (xx != x || yy != y) { 
                                      b[xx][yy] = true; 
                                  } 
                              } 
                          } 
                          break; 
   
                  } 
              } 
          } 
          int res = 0; 
          for (int i = 0; i < 16; i++) { 
              for (int j = 0; j < 16; j++) { 
                  if (a[i][j] > 0 && b[i][j]) { 
                      res++; 
                  } 
              } 
          } 
          return "" + res; 
      } 
   
      private boolean isValid(int x, int y) { 
          return (x >= 0) && (x < 16) && (y >= 0) && (y < 16); 
      } 
  }