


import string

import numpy







def 						lowerCamelCase(   a__	,a__):
    return b if a == 0 else greatest_common_divisor(b % a	,a__)

class 						A__							:
      UpperCAmelCase             =						string.ascii_uppercase + string.digits
      # This cipher takes alphanumerics into account
      # i.e. a total of 36 characters

      # take x and return x % len(key_string)
      UpperCAmelCase             =						numpy.vectorize(lambda UpperCamelCase__  : x % 36  )

      UpperCAmelCase             =						numpy.vectorize(UpperCamelCase__  )




      def __init__(       self					:      int				,    _a					:      numpy.ndarray  )							->     None:


          """simple docstring"""





          _SCREAMING_SNAKE_CASE			  =self.modulus(_a  )  # mod36 calc's on the encrypt key
          self.check_determinant()  # validate the determinant of the encryption key
          _SCREAMING_SNAKE_CASE			  =encrypt_key.shape[0]




      def 							__UpperCamelCase				(       self					:      Dict				,    _a					:      str  )							->     int:


          """simple docstring"""





          return self.key_string.index(_a  )




      def 							__UpperCamelCase				(       self					:      List[str]				,    _a					:      int  )							->     str:


          """simple docstring"""





          return self.key_string[round(_a  )]




      def 							__UpperCamelCase				(       self					:      int  )							->     None:


          """simple docstring"""





          _SCREAMING_SNAKE_CASE			  =round(numpy.linalg.det(self.encrypt_key  )  )

          if det < 0:
              _SCREAMING_SNAKE_CASE			  =det % len(self.key_string  )

          _SCREAMING_SNAKE_CASE			  =len(self.key_string  )
          if greatest_common_divisor(_a				,    len(self.key_string  )  ) != 1:
              _SCREAMING_SNAKE_CASE			  =(
                  f"determinant modular {req_l} of encryption key({det}) "
                  f"is not co prime w.r.t {req_l}.\nTry another key."
              )
              raise ValueError(_a  )




      def 							__UpperCamelCase				(       self					:      List[str]				,    _a					:      str  )							->     str:


          """simple docstring"""





          _SCREAMING_SNAKE_CASE			  =[char for char in text.upper() if char in self.key_string]

          _SCREAMING_SNAKE_CASE			  =chars[-1]
          while len(_a  ) % self.break_key != 0:
              chars.append(_a  )

          return "".join(_a  )




      def 							__UpperCamelCase				(       self					:      List[str]				,    _a					:      str  )							->     str:


          """simple docstring"""





          _SCREAMING_SNAKE_CASE			  =self.process_text(text.upper()  )
          _SCREAMING_SNAKE_CASE			  =''''''

          for i in range(0				,    len(_a  ) - self.break_key + 1				,    self.break_key  ):
              _SCREAMING_SNAKE_CASE			  =text[i : i + self.break_key]
              _SCREAMING_SNAKE_CASE			  =[self.replace_letters(_a  ) for char in batch]
              _SCREAMING_SNAKE_CASE			  =numpy.array([vec]  ).T
              _SCREAMING_SNAKE_CASE			  =self.modulus(self.encrypt_key.dot(_a  )  ).T.tolist()[
                  0
              ]
              _SCREAMING_SNAKE_CASE			  =''''''.join(
                  self.replace_digits(_a  ) for num in batch_encrypted  )
              encrypted += encrypted_batch

          return encrypted




      def 							__UpperCamelCase				(       self					:      Union[str, Any]  )							->     numpy.ndarray:


          """simple docstring"""





          _SCREAMING_SNAKE_CASE			  =round(numpy.linalg.det(self.encrypt_key  )  )

          if det < 0:
              _SCREAMING_SNAKE_CASE			  =det % len(self.key_string  )
          _SCREAMING_SNAKE_CASE			  =None
          for i in range(len(self.key_string  )  ):
              if (det * i) % len(self.key_string  ) == 1:
                  _SCREAMING_SNAKE_CASE			  =i
                  break

          _SCREAMING_SNAKE_CASE			  =(
              det_inv
              * numpy.linalg.det(self.encrypt_key  )
              * numpy.linalg.inv(self.encrypt_key  )
          )

          return self.to_int(self.modulus(_a  )  )




      def 							__UpperCamelCase				(       self					:      str				,    _a					:      str  )							->     str:


          """simple docstring"""





          _SCREAMING_SNAKE_CASE			  =self.make_decrypt_key()
          _SCREAMING_SNAKE_CASE			  =self.process_text(text.upper()  )
          _SCREAMING_SNAKE_CASE			  =''''''

          for i in range(0				,    len(_a  ) - self.break_key + 1				,    self.break_key  ):
              _SCREAMING_SNAKE_CASE			  =text[i : i + self.break_key]
              _SCREAMING_SNAKE_CASE			  =[self.replace_letters(_a  ) for char in batch]
              _SCREAMING_SNAKE_CASE			  =numpy.array([vec]  ).T
              _SCREAMING_SNAKE_CASE			  =self.modulus(decrypt_key.dot(_a  )  ).T.tolist()[0]
              _SCREAMING_SNAKE_CASE			  =''''''.join(
                  self.replace_digits(_a  ) for num in batch_decrypted  )
              decrypted += decrypted_batch

          return decrypted







def 						lowerCamelCase(   ):
    _SCREAMING_SNAKE_CASE			  =int(input('''Enter the order of the encryption key: '''))
    _SCREAMING_SNAKE_CASE			  =[]

    print('''Enter each row of the encryption key with space separated integers''')
    for _ in range(a__):
        _SCREAMING_SNAKE_CASE			  =[int(a__) for x in input().split()]
        hill_matrix.append(a__)

    _SCREAMING_SNAKE_CASE			  =HillCipher(numpy.array(a__))

    print('''Would you like to encrypt or decrypt some text? (1 or 2)''')
    _SCREAMING_SNAKE_CASE			  =input('''\n1. Encrypt\n2. Decrypt\n''')
    if option == "1":
        _SCREAMING_SNAKE_CASE			  =input('''What text would you like to encrypt?: ''')
        print('''Your encrypted text is:''')
        print(hc.encrypt(a__))
    elif option == "2":
        _SCREAMING_SNAKE_CASE			  =input('''What text would you like to decrypt?: ''')
        print('''Your decrypted text is:''')
        print(hc.decrypt(a__))


if __name__ == "__main__":
       import doctest

       doctest.testmod()

       main()



from collections.abc import Generator







def 						lowerCamelCase(   ):
				_SCREAMING_SNAKE_CASE  ,				_SCREAMING_SNAKE_CASE			  =0, 1
				while True:
								_SCREAMING_SNAKE_CASE  ,				_SCREAMING_SNAKE_CASE			  =b, a + b
								yield b







def 						lowerCamelCase(   a__ = 1000):
				_SCREAMING_SNAKE_CASE			  =1
				_SCREAMING_SNAKE_CASE			  =fibonacci_generator()
				while len(str(next(a__))) < n:
								answer += 1
				return answer + 1


if __name__ == "__main__":
							print(solution(int(str(input()).strip())))