#include <fstream.h>
#include <stdio.h>

#define DBG(x) 

fstream inFile("anagram.in",ios::in);

#define MAX_GRP 1000
#define MAX_WORDS 10000

int grpMembersCnt[MAX_GRP];
char gruppen[MAX_GRP][200];
int gruppenNext[MAX_GRP];

char moreMembers[MAX_WORDS][200];
int nextMembers[MAX_WORDS];
int moreMembersCnt = 0;
int gruppenCnt = 0;

// 0: nein, 1: ja
int isAnagram(const char *inWord1, const char *inWord2) {
  char word1[200], word2[200];
  strcpy(word1,inWord1);
  strcpy(word2,inWord2);
  // ist das eine Wort ein Anagram des anderen?
  if (strlen(word1) != strlen(word2)) return 0;
  
  // es koennte sein
  int wordLen = strlen(word1);
  for (int i = 0; i < wordLen; i++) {
    char aktChar = word1[i];
    int j = 0;
    while ((word2[j] != aktChar) && (word2[j] != 0)) 
      j++;  
    if (word2[j] == 0) return 0;
    word2[j] = ' ';
  } 
  return 1;
}


void insertWord(int group, const char *aktWord) {
  // zuerst das Word sortiert in die Gruppe einfuegen
  
  // als neues erstes Word einfuegen
  if (strcmp(aktWord,gruppen[group]) < 0) {
    strcpy(moreMembers[moreMembersCnt],gruppen[group]);
    nextMembers[moreMembersCnt] = gruppenNext[group];
    strcpy(gruppen[group],aktWord);
    gruppenNext[group] = moreMembersCnt;
    moreMembersCnt++;
  } else {
    int aktPtr = gruppenNext[group];
    int prevPtr = -1;
    // mich selbst speichern
    strcpy(moreMembers[moreMembersCnt],aktWord);
    while (aktPtr != -1) {
      
      if (strcmp(aktWord,moreMembers[aktPtr]) < 0) {
        // jetzt das Wort einfuegen
	if (prevPtr == -1) {
	  nextMembers[moreMembersCnt] = gruppenNext[group];
	  gruppenNext[group] = moreMembersCnt;
	} else {
	  // zuerst den Zeiger von 1->2 in mein Feld schreiben
	  nextMembers[moreMembersCnt] = nextMembers[prevPtr];
	  nextMembers[prevPtr] = moreMembersCnt;
	}
      }
      
      prevPtr = aktPtr;
      aktPtr = nextMembers[aktPtr];
      // als letztes Element einfuegen
      if (aktPtr == -1) {
        nextMembers[prevPtr] = moreMembersCnt;
      }
    } 
    moreMembersCnt++;     
  }
  // jetzt die Gruppe innerhalb der Liste sortieren
  grpMembersCnt[group]++;
  
  // konkret: die Gruppe solange "sinken" lassen, bis sie 
  // entweder an pos 0 angekommen ist (return) oder
  // aber die andere Gruppe lexikalisch groesser bzw.
  // mehr Elemente hat
  
  while (group >= 1) {
    if ((grpMembersCnt[group] > grpMembersCnt[group-1]) ||
         ((grpMembersCnt[group] == grpMembersCnt[group-1]) &&
	  (strcmp(gruppen[group],gruppen[group-1]) < 0)))
    
    {  // die beiden Gruppen swappen
      char zwG[200];
      int zwGmc = grpMembersCnt[group];
      strcpy(zwG,gruppen[group]);
      int zwGn = gruppenNext[group];
      
      grpMembersCnt[group] = grpMembersCnt[group-1];
      strcpy(gruppen[group],gruppen[group-1]);
      gruppenNext[group] = gruppenNext[group-1];

      grpMembersCnt[group-1] = zwGmc;
      strcpy(gruppen[group-1],zwG);
      gruppenNext[group-1] = zwGn;
      
      group--;
    } else return;
  } 
}


void readWord() {
  char aktWord[200];
  inFile >> aktWord; 
  if (strlen(aktWord) == 0) return;
  
  // Wort in die Anagramgruppe einbauen
  for (int i = 0; i < gruppenCnt; i++) {
    if (isAnagram(aktWord,gruppen[i])) {
      insertWord(i,aktWord);
      DBG(printf("Word %s| in Gruppe %s|\n",aktWord,gruppen[i]);)
      return;
    } 
  }
  DBG(printf("neu: %s|\n",aktWord);)
  // wir muessen wohl eine neue Gruppe aufmachen...
  strcpy(gruppen[gruppenCnt],aktWord);
  gruppenNext[gruppenCnt] = -1;
  grpMembersCnt[gruppenCnt] = 1;
  gruppenCnt++;
}


void writeErg() {
  int i = 0;
  while ((i < 5) && (grpMembersCnt[i] >= 1)) {
    printf("Group of size %d: ",grpMembersCnt[i]);
    cout << gruppen[i] << " ";
    // jetzt die einzelnen Mitglieder ausgeben
    int aktPtr = gruppenNext[i];
    char *lastWord = gruppen[i];
    while (aktPtr != -1) {
      if (strcmp(lastWord,moreMembers[aktPtr]) != 0) 
        cout << moreMembers[aktPtr] << " ";
      lastWord = moreMembers[aktPtr];	
      aktPtr = nextMembers[aktPtr];	
    }
    cout << endl;
    i++;
  }
}


int main() {
  for (int i = 0; i < MAX_WORDS; i++) nextMembers[i] = -1;
  while (inFile) {
    readWord();
  }
  writeErg();
  return 0;
}