output_description: Print the number of pairs of integers i, j (1 \leq i < j \leq N) such that s_i
  is an anagram of s_j.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      s_1
      s_2
      :
      s_N
attempt: char_num = int(input())
  char_length = 10
  chars = []
  for i in range(char_num):
      chars.append(input())
  
  
  class CharArrange:
      def __init__(self, char):
          self.char = char
  
      def char_run(self):
          list_char = self.str2ord_list(self.char)
          for pos in range(1, len(list_char)):
              self.insert_sort(list_char, pos, list_char[pos])
          self.char = self.ordList2Str(list_char)
  
      def order_run(self, chars):
          for i, char in enumerate(chars):
              chars[i] = self.ord_list2ord_concat(self.str2ord_list(char))
          for pos in range(len(chars)):
              self.insert_sort(chars, pos, chars[pos])
          self.ord_chars = chars
  
      def str2ord_list(self, char):
          return list(map(ord, char))
  
      def ordList2Str(self, ordList):
          return "".join(list(map(chr, ordList)))
  
      def ord_list2ord_concat(self, ord_list):
          self.ord_concat = ""
          for ord_num in ord_list:
              self.ord_concat += str(ord_num)
          return int(self.ord_concat)
  
      def insert_sort(self, A, pos, value):
          i = pos - 1
          while i >= 0 and A[i] > value:
              A[i + 1] = A[i]
              i = i - 1
          A[i + 1] = value
          return A
  
  
  counter = 0
  hash_table = {}
  for i, char in enumerate(chars):
      CA = CharArrange(char)
      CA.char_run()
      if CA.char in hash_table:
          hash_table[CA.char] += 1
      else:
          hash_table[CA.char] = 0
      counter += hash_table[CA.char]
  
  
  print(counter)
  
problem_description: Statement
  
  We will call a string obtained by arranging the characters contained in a
  string a in some order, an _anagram_ of a.
  
  For example, `greenbin` is an anagram of `beginner`. As seen here, when the
  same character occurs multiple times, that character must be used that number
  of times.
  
  Given are N strings s_1, s_2, \ldots, s_N. Each of these strings has a length
  of 10 and consists of lowercase English characters. Additionally, all of these
  strings are distinct. Find the number of pairs of integers i, j (1 \leq i < j
  \leq N) such that s_i is an anagram of s_j.
samples: [{"input": "3\n    acornistnt\n    peanutbomb\n    constraint", "output": "1\n    \n\ns_1 = `acornistnt` is an anagram of s_3 = `constraint`. There are no other\npairs i, j such that s_i is an anagram of s_j, so the answer is 1.\n\n* * *"}, {"input": "2\n    oneplustwo\n    ninemodsix", "output": "0\n    \n\nIf there is no pair i, j such that s_i is an anagram of s_j, print 0.\n\n* * *"}, {"input": "5\n    abaaaaaaaa\n    oneplustwo\n    aaaaaaaaba\n    twoplusone\n    aaaabaaaaa", "output": "4\n    \n\nNote that the answer may not fit into a 32-bit integer type, though we cannot\nput such a case here."}]