'''simple docstring'''





from __future__ import annotations




class        __A      :



    def __init__(self    :    Optional[Any]   ,			__a    :    list[list[int]] ):
         UpperCAmelCase_           =   TypeError(
             "Matrices must be formed from a list of zero or more lists containing at "
             "least one and the same number of values, each of which must be of type "
             "int or float." )
         if len(__a ) != 0:
              UpperCAmelCase_           =   len(rows[0] )
              if cols == 0:
                   raise error
              for row in rows:
                   if len(__a ) != cols:
                        raise error
                   for value in row:
                        if not isinstance(__a   ,			(int, float) ):
                             raise error
              UpperCAmelCase_           =   rows
         else:
              UpperCAmelCase_           =   []



    def 					_lowercase						(self    :    Tuple ):
         return [[row[i] for row in self.rows] for i in range(len(self.rows[0] ) )]



    @property
    def 					_lowercase						(self    :    List[Any] ):
         return len(self.rows )



    @property
    def 					_lowercase						(self    :    Tuple ):
         return len(self.rows[0] )



    @property
    def 					_lowercase						(self    :    Tuple ):
         return (self.num_rows, self.num_columns)



    @property
    def 					_lowercase						(self    :    str ):
         return self.order[0] == self.order[1]



    def 					_lowercase						(self    :    int ):
         UpperCAmelCase_           =   [
             [0 if column_num != row_num else 1 for column_num in range(self.num_rows )]
             for row_num in range(self.num_rows )
         ]
         return Matrix(__a )



    def 					_lowercase						(self    :    List[Any] ):
         if not self.is_square:
              return 0
         if self.order == (0, 0):
              return 1
         if self.order == (1, 1):
              return int(self.rows[0][0] )
         if self.order == (2, 2):
              return int(
                  (self.rows[0][0] * self.rows[1][1])
                  - (self.rows[0][1] * self.rows[1][0]) )
         else:
              return sum(
                  self.rows[0][column] * self.cofactors().rows[0][column]
                  for column in range(self.num_columns ) )



    def 					_lowercase						(self    :    int ):
         return bool(self.determinant() )



    def 					_lowercase						(self    :    Union[str, Any]   ,			__a    :    int   ,			__a    :    int ):
         UpperCAmelCase_           =   [
             [
                 self.rows[other_row][other_column]
                 for other_column in range(self.num_columns )
                 if other_column != column
             ]
             for other_row in range(self.num_rows )
             if other_row != row
         ]
         return Matrix(__a ).determinant()



    def 					_lowercase						(self    :    Optional[int]   ,			__a    :    int   ,			__a    :    int ):
         if (row + column) % 2 == 0:
              return self.get_minor(__a   ,			__a )
         return -1 * self.get_minor(__a   ,			__a )



    def 					_lowercase						(self    :    Optional[int] ):
         return Matrix(
             [
                 [self.get_minor(__a   ,			__a ) for column in range(self.num_columns )]
                 for row in range(self.num_rows )
             ] )



    def 					_lowercase						(self    :    Optional[int] ):
         return Matrix(
             [
                 [
                     self.minors().rows[row][column]
                     if (row + column) % 2 == 0
                     else self.minors().rows[row][column] * -1
                     for column in range(self.minors().num_columns )
                 ]
                 for row in range(self.minors().num_rows )
             ] )



    def 					_lowercase						(self    :    Tuple ):
         UpperCAmelCase_           =   [
             [self.cofactors().rows[column][row] for column in range(self.num_columns )]
             for row in range(self.num_rows )
         ]
         return Matrix(__a )



    def 					_lowercase						(self    :    List[str] ):
         UpperCAmelCase_           =   self.determinant()
         if not determinant:
              raise TypeError("Only matrices with a non-zero determinant have an inverse" )
         return self.adjugate() * (1 / determinant)



    def __repr__(self    :    Optional[int] ):
         return str(self.rows )



    def __str__(self    :    Optional[int] ):
         if self.num_rows == 0:
              return "[]"
         if self.num_rows == 1:
              return "[[" + ". ".join(str(self.rows[0] ) ) + "]]"
         return (
             "["
             + "\n ".join(
                 [
                     "[" + ". ".join([str(__a ) for value in row] ) + ".]"
                     for row in self.rows
                 ] )
             + "]"
         )



    def 					_lowercase						(self    :    Dict   ,			__a    :    list[int]   ,			__a    :    int | None = None ):
         UpperCAmelCase_           =   TypeError("Row must be a list containing all ints and/or floats" )
         if not isinstance(__a   ,			__a ):
              raise type_error
         for value in row:
              if not isinstance(__a   ,			(int, float) ):
                   raise type_error
         if len(__a ) != self.num_columns:
              raise ValueError(
                  "Row must be equal in length to the other rows in the matrix" )
         if position is None:
              self.rows.append(__a )
         else:
              UpperCAmelCase_           =   self.rows[0:position] + [row] + self.rows[position:]



    def 					_lowercase						(self    :    Union[str, Any]   ,			__a    :    list[int]   ,			__a    :    int | None = None ):
         UpperCAmelCase_           =   TypeError(
             "Column must be a list containing all ints and/or floats" )
         if not isinstance(__a   ,			__a ):
              raise type_error
         for value in column:
              if not isinstance(__a   ,			(int, float) ):
                   raise type_error
         if len(__a ) != self.num_rows:
              raise ValueError(
                  "Column must be equal in length to the other columns in the matrix" )
         if position is None:
              UpperCAmelCase_           =   [self.rows[i] + [column[i]] for i in range(self.num_rows )]
         else:
              UpperCAmelCase_           =   [
                  self.rows[i][0:position] + [column[i]] + self.rows[i][position:]
                  for i in range(self.num_rows )
              ]



    def __eq__(self    :    Optional[Any]   ,			__a    :    object ):
         if not isinstance(__a   ,			__a ):
              return NotImplemented
         return self.rows == other.rows



    def __ne__(self    :    Union[str, Any]   ,			__a    :    object ):
         return not self == other



    def __neg__(self    :    Optional[Any] ):
         return self * -1



    def __add__(self    :    Union[str, Any]   ,			__a    :    Matrix ):
         if self.order != other.order:
              raise ValueError("Addition requires matrices of the same order" )
         return Matrix(
             [
                 [self.rows[i][j] + other.rows[i][j] for j in range(self.num_columns )]
                 for i in range(self.num_rows )
             ] )



    def __sub__(self    :    Tuple   ,			__a    :    Matrix ):
         if self.order != other.order:
              raise ValueError("Subtraction requires matrices of the same order" )
         return Matrix(
             [
                 [self.rows[i][j] - other.rows[i][j] for j in range(self.num_columns )]
                 for i in range(self.num_rows )
             ] )



    def __mul__(self    :    Dict   ,			__a    :    Matrix | int | float ):
         if isinstance(__a   ,			(int, float) ):
              return Matrix(
                  [[int(element * other ) for element in row] for row in self.rows] )
         elif isinstance(__a   ,			__a ):
              if self.num_columns != other.num_rows:
                   raise ValueError(
                       "The number of columns in the first matrix must "
                       "be equal to the number of rows in the second" )
              return Matrix(
                  [
                      [Matrix.dot_product(__a   ,			__a ) for column in other.columns()]
                      for row in self.rows
                  ] )
         else:
              raise TypeError(
                  "A Matrix can only be multiplied by an int, float, or another matrix" )



    def __pow__(self    :    Optional[Any]   ,			__a    :    int ):
         if not isinstance(__a   ,			__a ):
              raise TypeError("A Matrix can only be raised to the power of an int" )
         if not self.is_square:
              raise ValueError("Only square matrices can be raised to a power" )
         if other == 0:
              return self.identity()
         if other < 0:
              if self.is_invertable():
                   return self.inverse() ** (-other)
              raise ValueError(
                  "Only invertable matrices can be raised to a negative power" )
         UpperCAmelCase_           =   self
         for _ in range(other - 1 ):
              result *= self
         return result






    @classmethod
    def 					_lowercase						(cls    :    Any   ,			__a    :    list[int]   ,			__a    :    list[int] ):
         return sum(row[i] * column[i] for i in range(len(__a ) ) )


if __name__ == "__main__":
    import doctest

    doctest.testmod()





'''simple docstring'''





import math





def 	lowerCAmelCase_				(					)    ->      None:


     '''simple docstring'''




     UpperCAmelCase_           =   input("Enter message: "			)
     UpperCAmelCase_           =   int(input(f"""Enter key [2-{len(snake_case_			) - 1}]: """			)			)
     UpperCAmelCase_           =   input("Encryption/Decryption [e/d]: "			)

     if mode.lower().startswith("e"			):
          UpperCAmelCase_           =   encrypt_message(snake_case_					,    snake_case_			)
     elif mode.lower().startswith("d"			):
          UpperCAmelCase_           =   decrypt_message(snake_case_					,    snake_case_			)

     # Append pipe symbol (vertical bar) to identify spaces at the end.
     print(f"""Output:\n{text + "|"}"""			)





def 	lowerCAmelCase_				(					snake_case_       : int					,    snake_case_       : str			)    ->      str:


     '''simple docstring'''




     UpperCAmelCase_           =   [""] * key
     for col in range(snake_case_			):
          UpperCAmelCase_           =   col
          while pointer < len(snake_case_			):
               cipher_text[col] += message[pointer]
               pointer += key
     return "".join(snake_case_			)





def 	lowerCAmelCase_				(					snake_case_       : int					,    snake_case_       : str			)    ->      str:


     '''simple docstring'''




     UpperCAmelCase_           =   math.ceil(len(snake_case_			) / key			)
     UpperCAmelCase_           =   key
     UpperCAmelCase_           =   (num_cols * num_rows) - len(snake_case_			)
     UpperCAmelCase_           =   [""] * num_cols
     UpperCAmelCase_           =   0
     UpperCAmelCase_           =   0

     for symbol in message:
          plain_text[col] += symbol
          col += 1

          if (
              (col == num_cols)
              or (col == num_cols - 1)
              and (row >= num_rows - num_shaded_boxes)
          ):
               UpperCAmelCase_           =   0
               row += 1

     return "".join(snake_case_			)


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    main()




