from __future__ import annotations



class     _A   :






  def __init__(self   ,				SCREAMING_SNAKE_CASE_	)		->      int:





       '''simple docstring'''





       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(SCREAMING_SNAKE_CASE_	) != 0:
            UpperCamelCase__										=      len(rows[0]	)
            if cols == 0:
                 raise error
            for row in rows:
                 if len(SCREAMING_SNAKE_CASE_	) != cols:
                      raise error
                 for value in row:
                      if not isinstance(SCREAMING_SNAKE_CASE_   ,				(int, float)	):
                           raise error
            UpperCamelCase__										=      rows
       else:
            UpperCamelCase__										=      []






  def 		_a					(self	)		->      list[list[int]]:





       '''simple docstring'''





       return [[row[i] for row in self.rows] for i in range(len(self.rows[0]	)	)]






  @property
  def 		_a					(self	)		->      int:





       '''simple docstring'''





       return len(self.rows	)






  @property
  def 		_a					(self	)		->      int:





       '''simple docstring'''





       return len(self.rows[0]	)






  @property
  def 		_a					(self	)		->      tuple[int, int]:





       '''simple docstring'''





       return (self.num_rows, self.num_columns)






  @property
  def 		_a					(self	)		->      bool:





       '''simple docstring'''





       return self.order[0] == self.order[1]






  def 		_a					(self	)		->      Matrix:





       '''simple docstring'''





       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(SCREAMING_SNAKE_CASE_	)






  def 		_a					(self	)		->      int:





       '''simple docstring'''





       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 		_a					(self	)		->      bool:





       '''simple docstring'''





       return bool(self.determinant()	)






  def 		_a					(self   ,				SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_	)		->      int:





       '''simple docstring'''





       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(SCREAMING_SNAKE_CASE_	).determinant()






  def 		_a					(self   ,				SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_	)		->      int:





       '''simple docstring'''





       if (row + column) % 2 == 0:
            return self.get_minor(SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_	)
       return -1 * self.get_minor(SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_	)






  def 		_a					(self	)		->      Matrix:





       '''simple docstring'''





       return Matrix(
           [
               [self.get_minor(SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_	) for column in range(self.num_columns	)]
               for row in range(self.num_rows	)
           ]	)






  def 		_a					(self	)		->      Matrix:





       '''simple docstring'''





       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 		_a					(self	)		->      Matrix:





       '''simple docstring'''





       UpperCamelCase__										=      [
           [self.cofactors().rows[column][row] for column in range(self.num_columns	)]
           for row in range(self.num_rows	)
       ]
       return Matrix(SCREAMING_SNAKE_CASE_	)






  def 		_a					(self	)		->      Matrix:





       '''simple docstring'''





       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	)		->      str:





       '''simple docstring'''





       return str(self.rows	)






  def __str__(self	)		->      str:





       '''simple docstring'''





       if self.num_rows == 0:
            return "[]"
       if self.num_rows == 1:
            return "[[" + ". ".join(str(self.rows[0]	)	) + "]]"
       return (
           "["
           + "\n ".join(
               [
                   '''[''' + '''. '''.join([str(SCREAMING_SNAKE_CASE_	) for value in row]	) + '''.]'''
                   for row in self.rows
               ]	)
           + "]"
       )






  def 		_a					(self   ,				SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_ = None	)		->      None:





       '''simple docstring'''





       UpperCamelCase__										=      TypeError('''Row must be a list containing all ints and/or floats'''	)
       if not isinstance(SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_	):
            raise type_error
       for value in row:
            if not isinstance(SCREAMING_SNAKE_CASE_   ,				(int, float)	):
                 raise type_error
       if len(SCREAMING_SNAKE_CASE_	) != 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(SCREAMING_SNAKE_CASE_	)
       else:
            UpperCamelCase__										=      self.rows[0:position] + [row] + self.rows[position:]






  def 		_a					(self   ,				SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_ = None	)		->      None:





       '''simple docstring'''





       UpperCamelCase__										=      TypeError(
           '''Column must be a list containing all ints and/or floats'''	)
       if not isinstance(SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_	):
            raise type_error
       for value in column:
            if not isinstance(SCREAMING_SNAKE_CASE_   ,				(int, float)	):
                 raise type_error
       if len(SCREAMING_SNAKE_CASE_	) != 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   ,				SCREAMING_SNAKE_CASE_	)		->      bool:





       '''simple docstring'''





       if not isinstance(SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_	):
            return NotImplemented
       return self.rows == other.rows






  def __ne__(self   ,				SCREAMING_SNAKE_CASE_	)		->      bool:





       '''simple docstring'''





       return not self == other






  def __neg__(self	)		->      Matrix:





       '''simple docstring'''





       return self * -1






  def __add__(self   ,				SCREAMING_SNAKE_CASE_	)		->      Matrix:





       '''simple docstring'''





       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   ,				SCREAMING_SNAKE_CASE_	)		->      Matrix:





       '''simple docstring'''





       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   ,				SCREAMING_SNAKE_CASE_	)		->      Matrix:





       '''simple docstring'''





       if isinstance(SCREAMING_SNAKE_CASE_   ,				(int, float)	):
            return Matrix(
                [[int(element * other	) for element in row] for row in self.rows]	)
       elif isinstance(SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_	):
            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(SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_	) 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   ,				SCREAMING_SNAKE_CASE_	)		->      Matrix:





       '''simple docstring'''





       if not isinstance(SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_	):
            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 		_a					(cls   ,				SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_	)		->      int:





       '''simple docstring'''





       return sum(row[i] * column[i] for i in range(len(SCREAMING_SNAKE_CASE_	)	)	)


if __name__ == "__main__":
     import doctest

     doctest.testmod()




def  __UpperCamelCase    (						A = 600851475143							):

     try:
          UpperCamelCase__										=      int(A							)
     except (TypeError, ValueError):
          raise TypeError('''Parameter n must be int or castable to int.'''							)
     if n <= 0:
          raise ValueError('''Parameter n must be greater than or equal to one.'''							)
     UpperCamelCase__										=      1
     UpperCamelCase__										=      2
     while i * i <= n:
          while n % i == 0:
               UpperCamelCase__										=      i
               n //= i
          i += 1
     if n > 1:
          UpperCamelCase__										=      n
     return int(A							)


if __name__ == "__main__":
     print(f"""{solution() = }""")



