/* Subject: Contest submission for problem #1, file 1.java */
/* cs61a-mb@imail.EECS.Berkeley.EDU */
/* Thu Sep 11 10:58:59 PDT 2003 */
/*___CONTEST_SUBMISSION___ cs61a-mb 1 */
/**
 * CS 198, Fall 2003
 * Assignment #2, Problem #1
 */

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.LinkedList;

class P1 {
  private static BufferedReader reader =
      new BufferedReader(new InputStreamReader(System.in));

  public static void main(String[] args) throws IOException {
    LinkedList squares = new LinkedList();
    String line;

    while ((line = reader.readLine()) != null &&
           !line.equals("0")) {
      squares.add(readSquare(Integer.parseInt(line)));
    }

    for (Iterator iterator = squares.iterator(); iterator.hasNext();) {
      printSquare((Square)iterator.next());
    }
  }

  public static Square readSquare(int elements) throws IOException {
    Square square = new Square(elements);

    for (int row = 0; row < elements; row++) {
      String line = reader.readLine();

      for (int column = 0; column < elements; column++) {
        square.setElement(row, column, line.charAt(column));
      }
    }

    return square;
  }

  public static void printSquare(Square square) {
    LinkedList squares = new LinkedList();
    squares.add(square);
    squares.addAll(square.getInnerSquares());
    CharacterCounter counter = new CharacterCounter(square);

    for (Iterator iterator = squares.iterator(); iterator.hasNext();) {
      square = (Square)iterator.next();

      if (square.isUniform()) {
        counter.increment(square.getElement(0, 0), 4);
      }
      else {
        if (square.equals(square.getTranspose())) {
          counter.increment(square.getElement(0, square.getSize() - 1), 1);
        }

        if (square.equals(square.getRotated().getTranspose())) {
          counter.increment(square.getElement(0, square.getSize() - 1), 1);
        }
      }

      if (square.getSize() % 2 == 1) {
        if (square.isUniform()) {
          counter.increment(square.getElement(0, 0), 4);
        }
        else {
          for (int rotations = 0; rotations < 3; rotations++) {
            if (square.equals(square.getFlipped())) {
              counter.increment(square.getElement(0, square.getSize() - 1), 1);
            }

            square = square.getRotated();
          }
        }
      }
    }

    System.out.print("(" + counter.getTotalCount() + ")");

    for (int index = 0; index < counter.getSize(); index++) {
      char character = counter.getCharacter(index);
      System.out.print(" " + character + " " + counter.getCount(character));
    }

    System.out.println();
  }
}
// (10) 1 A 9 B
// (51) 1 A 50 B
class CharacterCounter {
  private char[] characters = new char[20 * 20];
  private int[] counts = new int[20 * 20];
  private int size = 0, totalCount = 0;

  public CharacterCounter(Square square) {
    for (int row = 0; row < square.getSize(); row++) {
      for (int column = 0; column < square.getSize(); column++) {
        char character = square.getElement(row, column);

        if (getIndex(character) == -1) {
          characters[size] = character;
          counts[size] = 0;
          size++;
        }
      }
    }
  }

  public char getCharacter(int index) {
    return characters[index];
  }

  public int getCount(char character) {
    int index = getIndex(character);

    return index == -1 ? -1 : counts[index];
  }

  public int getSize() {
    return size;
  }

  public int getTotalCount() {
    return totalCount;
  }

  public void increment(char character, int count) {
    int index = getIndex(character);

    if (index != -1) {
      counts[index] += count;
      totalCount += count;
    }
  }

  private int getIndex(char character) {
    for (int index = 0; index < characters.length; index++) {
      if (characters[index] == character) {
        return index;
      }
    }

    return -1;
  }
}

class Square {
  char[][] characters;

  public Square(int elements) {
    characters = new char[elements][elements];
  }

  public boolean equals(Square square) {
    if (characters.length != square.characters.length) {
      return false;
    }

    for (int row = 0; row < characters.length; row++) {
      for (int column = 0; column < characters.length; column++) {
        if (characters[row][column] != square.characters[row][column]) {
          return false;
        }
      }
    }

    return true;
  }

  public char getElement(int row, int column) {
    return characters[row][column];
  }

  public Square getFlipped() {
    Square square = new Square(characters.length);

    for (int row = 0; row < characters.length; row++) {
      for (int column = 0; column < characters.length; column++) {
        square.characters[characters.length - row - 1][column] =
            characters[row][column];
      }
    }

    return square;
  }


  public Square getInnerSquare(int firstRow, int firstColumn,
                                   int elements) {
    Square square = new Square(elements);

    for (int row = 0; row < elements; row++) {
      for (int column = 0; column < elements; column++) {
        square.characters[row][column] =
            characters[row + firstRow][column + firstColumn];
      }
    }

    return square;
  }

  public LinkedList getInnerSquares() {
    LinkedList innerSquares = new LinkedList();

    for (int elements = 2; elements < characters.length; elements++) {
      innerSquares.add(getInnerSquare(0, 0, elements));
      innerSquares.add(getInnerSquare(0, characters.length - elements,
                                         elements));
      innerSquares.add(getInnerSquare(characters.length - elements, 0,
                                         elements));
      innerSquares.add(getInnerSquare(characters.length - elements,
                                         characters.length - elements,
                                         elements));
    }

    return innerSquares;
  }

  public Square getRotated() {
    Square square = new Square(characters.length);

    for (int row = 0; row < characters.length; row++) {
      for (int column = 0; column < characters.length; column++) {
        square.characters[row][characters.length - column - 1] =
            characters[row][column];
      }
    }

    return square;
  }

  public int getSize() {
    return characters.length;
  }

  public Square getTranspose() {
    Square square = new Square(characters.length);

    for (int row = 0; row < characters.length; row++) {
      for (int column = 0; column < characters.length; column++) {
        square.characters[row][column] = characters[column][row];
      }
    }

    return square;
  }

  public boolean isUniform() {
    char character = characters[0][0];

    for (int row = 0; row < characters.length; row++) {
      for (int column = 1; column < characters.length; column++) {
        if (characters[row][column] != character) {
          return false;
        }
      }
    }

    return true;
  }

  public void setElement(int row, int column, char value) {
    characters[row][column] = value;
  }

  public String toString() {
    StringBuffer string = new StringBuffer((characters.length + 1) *
                                           characters.length - 1);
    for (int row = 0; row < characters.length; row++) {
      string.append(characters[row]);

      if (row != characters.length - 1) {
        string.append('\n');
      }
    }

    return string.toString();
  }
}