
import numpy as np

__UpperCAmelCase   						=     [
    ["a", "b", "c", "d", "e"],
    ["f", "g", "h", "i", "k"],
    ["l", "m", "n", "o", "p"],
    ["q", "r", "s", "t", "u"],
    ["v", "w", "x", "y", "z"],
]





class 				UpperCamelCase__		:






       """simple docstring"""


       def __init__(							self	)				->				None:
          SCREAMING_SNAKE_CASE_	=      np.array(_A	)



       def     _UpperCamelCase	(							self ,     _A	)				->				np.ndarray:
          SCREAMING_SNAKE_CASE_	, SCREAMING_SNAKE_CASE_	=      np.where(letter == self.SQUARE	)
          SCREAMING_SNAKE_CASE_	=      np.concatenate([indexa + 1, indexa + 1]	)
          return indexes



       def     _UpperCamelCase	(							self ,     _A ,     _A	)				->				str:
          return self.SQUARE[indexa - 1, indexa - 1]



       def     _UpperCamelCase	(							self ,     _A	)				->				str:
          SCREAMING_SNAKE_CASE_	=      message.lower()
          SCREAMING_SNAKE_CASE_	=      message.replace('''j''' ,     '''i'''	)

          SCREAMING_SNAKE_CASE_	=      ''''''
          for letter_index in range(len(_A	)	):
             if message[letter_index] != " ":
                SCREAMING_SNAKE_CASE_	=      self.letter_to_numbers(message[letter_index]	)
                SCREAMING_SNAKE_CASE_	=      encoded_message + str(numbers[0]	) + str(numbers[1]	)
             elif message[letter_index] == " ":
                SCREAMING_SNAKE_CASE_	=      encoded_message + ''' '''

          return encoded_message




       def     _UpperCamelCase	(							self ,     _A	)				->				str:
          SCREAMING_SNAKE_CASE_	=      message.replace(''' ''' ,     '''  '''	)
          SCREAMING_SNAKE_CASE_	=      ''''''
          for numbers_index in range(int(len(_A	) / 2	)	):
             if message[numbers_index * 2] != " ":
                SCREAMING_SNAKE_CASE_	=      message[numbers_index * 2]
                SCREAMING_SNAKE_CASE_	=      message[numbers_index * 2 + 1]

                SCREAMING_SNAKE_CASE_	=      self.numbers_to_letter(int(_A	) ,     int(_A	)	)
                SCREAMING_SNAKE_CASE_	=      decoded_message + letter
             elif message[numbers_index * 2] == " ":
                SCREAMING_SNAKE_CASE_	=      decoded_message + ''' '''

          return decoded_message




from math import sqrt


def  A__ (       __lowerCamelCase						):
   SCREAMING_SNAKE_CASE_	=      [1]
   for i in range(2,  int(sqrt(__lowerCamelCase						)						) + 1,  1						):
      if number % i == 0:
         values.append(__lowerCamelCase						)
         if int(number // i						) != i:
            values.append(int(number // i						)						)
   return sorted(__lowerCamelCase						)


def  A__ (       __lowerCamelCase						):
   return sum(factors(__lowerCamelCase						)						) > n


def  A__ (       __lowerCamelCase						):
   SCREAMING_SNAKE_CASE_	=      factors(__lowerCamelCase						)
   SCREAMING_SNAKE_CASE_	=      len(__lowerCamelCase						)
   SCREAMING_SNAKE_CASE_	=      [[0 for i in range(number + 1						)] for j in range(r + 1						)]
   for i in range(r + 1						):
      SCREAMING_SNAKE_CASE_	=      True

   for i in range(1,  number + 1						):
      SCREAMING_SNAKE_CASE_	=      False

   for i in range(1,  r + 1						):
      for j in range(1,  number + 1						):
         if j < values[i - 1]:
            SCREAMING_SNAKE_CASE_	=      subset[i - 1][j]
         else:
            SCREAMING_SNAKE_CASE_	=      subset[i - 1][j] or subset[i - 1][j - values[i - 1]]

   return subset[r][number] != 0


def  A__ (       __lowerCamelCase						):
   return abundant(__lowerCamelCase						) and not semi_perfect(__lowerCamelCase						)


if __name__ == "__main__":
   import doctest

   doctest.testmod(verbose=True)
   for number in (69, 70, 71):
      print(F"""{number} is {'' if weird(number) else 'not '}weird.""")


