




from __future__ import annotations



class      a	:

     '''simple docstring'''





     def __init__(      self  :     Optional[Any]   ,       __snake_case  :     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(_lowerCAmelCase							) != 0:
             UpperCAmelCase_									=	len(rows[0]							)
             if cols == 0:
                 raise error
             for row in rows:
                 if len(_lowerCAmelCase							) != cols:
                     raise error
                 for value in row:
                     if not isinstance(_lowerCAmelCase   ,       (int, float)							):
                         raise error
             UpperCAmelCase_									=	rows
         else:
             UpperCAmelCase_									=	[]
     def     lowerCamelCase_  (      self  :     int							):
         return [[row[i] for row in self.rows] for i in range(len(self.rows[0]							)							)]
     @property
     def     lowerCamelCase_  (      self  :     Any							):
         return len(self.rows							)
     @property
     def     lowerCamelCase_  (      self  :     Dict							):
         return len(self.rows[0]							)
     @property
     def     lowerCamelCase_  (      self  :     int							):
         return (self.num_rows, self.num_columns)
     @property
     def     lowerCamelCase_  (      self  :     str							):
         return self.order[0] == self.order[1]
     def     lowerCamelCase_  (      self  :     Dict							):
         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(_lowerCAmelCase							)
     def     lowerCamelCase_  (      self  :     int							):
         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     lowerCamelCase_  (      self  :     Union[str, Any]							):
         return bool(self.determinant()							)
     def     lowerCamelCase_  (      self  :     Union[str, Any]   ,       __snake_case  :     int   ,       __snake_case  :     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(_lowerCAmelCase							).determinant()
     def     lowerCamelCase_  (      self  :     int   ,       __snake_case  :     int   ,       __snake_case  :     int							):
         if (row + column) % 2 == 0:
             return self.get_minor(_lowerCAmelCase   ,       _lowerCAmelCase							)
         return -1 * self.get_minor(_lowerCAmelCase   ,       _lowerCAmelCase							)
     def     lowerCamelCase_  (      self  :     Optional[int]							):
         return Matrix(
             [
                 [self.get_minor(_lowerCAmelCase   ,       _lowerCAmelCase							) for column in range(self.num_columns							)]
                 for row in range(self.num_rows							)
             ]							)
     def     lowerCamelCase_  (      self  :     Union[str, Any]							):
         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     lowerCamelCase_  (      self  :     List[Any]							):
         UpperCAmelCase_									=	[
             [self.cofactors().rows[column][row] for column in range(self.num_columns							)]
             for row in range(self.num_rows							)
         ]
         return Matrix(_lowerCAmelCase							)
     def     lowerCamelCase_  (      self  :     List[Any]							):
         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  :     Union[str, Any]							):
         if self.num_rows == 0:
             return "[]"
         if self.num_rows == 1:
             return "[[" + ". ".join(str(self.rows[0]							)							) + "]]"
         return (
             "["
             + "\n ".join(
                 [
                     '''[''' + '''. '''.join([str(_lowerCAmelCase							) for value in row]							) + '''.]'''
                     for row in self.rows
                 ]							)
             + "]"
         )
     def     lowerCamelCase_  (      self  :     Union[str, Any]   ,       __snake_case  :     list[int]   ,       __snake_case  :     int | None = None							):
         UpperCAmelCase_									=	TypeError('''Row must be a list containing all ints and/or floats'''							)
         if not isinstance(_lowerCAmelCase   ,       _lowerCAmelCase							):
             raise type_error
         for value in row:
             if not isinstance(_lowerCAmelCase   ,       (int, float)							):
                 raise type_error
         if len(_lowerCAmelCase							) != 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(_lowerCAmelCase							)
         else:
             UpperCAmelCase_									=	self.rows[0:position] + [row] + self.rows[position:]
     def     lowerCamelCase_  (      self  :     str   ,       __snake_case  :     list[int]   ,       __snake_case  :     int | None = None							):
         UpperCAmelCase_									=	TypeError(
             '''Column must be a list containing all ints and/or floats'''							)
         if not isinstance(_lowerCAmelCase   ,       _lowerCAmelCase							):
             raise type_error
         for value in column:
             if not isinstance(_lowerCAmelCase   ,       (int, float)							):
                 raise type_error
         if len(_lowerCAmelCase							) != 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  :     Union[str, Any]   ,       __snake_case  :     object							):
         if not isinstance(_lowerCAmelCase   ,       _lowerCAmelCase							):
             return NotImplemented
         return self.rows == other.rows
     def __ne__(      self  :     List[str]   ,       __snake_case  :     object							):
         return not self == other
     def __neg__(      self  :     Union[str, Any]							):
         return self * -1
     def __add__(      self  :     Tuple   ,       __snake_case  :     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  :     Any   ,       __snake_case  :     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  :     str   ,       __snake_case  :     Matrix | int | float							):
         if isinstance(_lowerCAmelCase   ,       (int, float)							):
             return Matrix(
                 [[int(element * other							) for element in row] for row in self.rows]							)
         elif isinstance(_lowerCAmelCase   ,       _lowerCAmelCase							):
             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(_lowerCAmelCase   ,       _lowerCAmelCase							) 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[int]   ,       __snake_case  :     int							):
         if not isinstance(_lowerCAmelCase   ,       _lowerCAmelCase							):
             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     lowerCamelCase_  (      cls  :     List[Any]   ,       __snake_case  :     list[int]   ,       __snake_case  :     list[int]							):
         return sum(row[i] * column[i] for i in range(len(_lowerCAmelCase							)							)							)


if __name__ == "__main__":
 import doctest

 doctest.testmod()









def       _lowerCAmelCase    (				lowerCAmelCase_				:List[str]		,    lowerCAmelCase_				:int				)->Optional[int]:
   '''simple docstring'''






   snake_case_            =       0
   while b > 0:
      if b & 1:
         res += a

      a += a
      b >>= 1

   return res



def       _lowerCAmelCase    (				lowerCAmelCase_				:int		,    lowerCAmelCase_				:List[str]		,    lowerCAmelCase_				:Dict				)->Dict:
   '''simple docstring'''






   snake_case_            =       0
   while b > 0:
      if b & 1:
         snake_case_            =       ((res % c) + (a % c)) % c

      a += a
      b >>= 1

   return res




