


"""simple docstring"""






from __future__ import annotations

from typing import Any


class     __lowerCamelCase  :

     '''simple docstring'''


     def __init__(      self    ,				__UpperCAmelCase    ,				__UpperCAmelCase    ,				__UpperCAmelCase = 0							)       ->							None:
          _a	,      _a    	=				row, column
          _a    	=				[[default_value for c in range(__UpperCAmelCase							)] for r in range(__UpperCAmelCase							)]


     def __str__(      self							)       ->							str:
          _a    	=				F'Matrix consist of {self.row} rows and {self.column} columns\n'

          # Make string identifier
          _a    	=				0
          for row_vector in self.array:
               for obj in row_vector:
                    _a    	=				max(__UpperCAmelCase    ,				len(str(__UpperCAmelCase							)							)							)
          _a    	=				F'%{max_element_length}s'

          # Make string and return
          def single_line(__UpperCAmelCase							) -> str:
               nonlocal string_format_identifier
               _a    	=				'''['''
               line += ", ".join(string_format_identifier % (obj,) for obj in row_vector							)
               line += "]"
               return line

          s += "\n".join(single_line(__UpperCAmelCase							) for row_vector in self.array							)
          return s


     def __repr__(      self							)       ->							str:
          return str(self							)


     def 							_UpperCAmelCase      (      self    ,				__UpperCAmelCase							)       ->							bool:
          if not (isinstance(__UpperCAmelCase    ,				(list, tuple)							) and len(__UpperCAmelCase							) == 2):
               return False
          elif not (0 <= loc[0] < self.row and 0 <= loc[1] < self.column):
               return False
          else:
               return True


     def __getitem__(      self    ,				__UpperCAmelCase							)       ->							Any:
          assert self.validate_indicies(__UpperCAmelCase							)
          return self.array[loc[0]][loc[1]]


     def __setitem__(      self    ,				__UpperCAmelCase    ,				__UpperCAmelCase							)       ->							None:
          assert self.validate_indicies(__UpperCAmelCase							)
          _a    	=				value


     def __add__(      self    ,				__UpperCAmelCase							)       ->							Matrix:
          assert isinstance(__UpperCAmelCase    ,				__UpperCAmelCase							)
          assert self.row == another.row and self.column == another.column

          # Add
          _a    	=				Matrix(self.row    ,				self.column							)
          for r in range(self.row							):
               for c in range(self.column							):
                    _a    	=				self[r, c] + another[r, c]
          return result


     def __neg__(      self							)       ->							Matrix:
          _a    	=				Matrix(self.row    ,				self.column							)
          for r in range(self.row							):
               for c in range(self.column							):
                    _a    	=				-self[r, c]
          return result


     def __sub__(      self    ,				__UpperCAmelCase							)       ->							Matrix:
          return self + (-another)


     def __mul__(      self    ,				__UpperCAmelCase							)       ->							Matrix:

          if isinstance(__UpperCAmelCase    ,				(int, float)							):  # Scalar multiplication
               _a    	=				Matrix(self.row    ,				self.column							)
               for r in range(self.row							):
                    for c in range(self.column							):
                         _a    	=				self[r, c] * another
               return result
          elif isinstance(__UpperCAmelCase    ,				__UpperCAmelCase							):  # Matrix multiplication
               assert self.column == another.row
               _a    	=				Matrix(self.row    ,				another.column							)
               for r in range(self.row							):
                    for c in range(another.column							):
                         for i in range(self.column							):
                              result[r, c] += self[r, i] * another[i, c]
               return result
          else:
               _a    	=				F'Unsupported type given for another ({type(__UpperCAmelCase							)})'
               raise TypeError(__UpperCAmelCase							)


     def 							_UpperCAmelCase      (      self							)       ->							Matrix:
          _a    	=				Matrix(self.column    ,				self.row							)
          for r in range(self.row							):
               for c in range(self.column							):
                    _a    	=				self[r, c]
          return result





     def 							_UpperCAmelCase      (      self    ,				__UpperCAmelCase    ,				__UpperCAmelCase							)       ->							Any:
          assert isinstance(__UpperCAmelCase    ,				__UpperCAmelCase							) and isinstance(__UpperCAmelCase    ,				__UpperCAmelCase							)
          assert self.row == self.column == u.row == v.row  # u, v should be column vector
          assert u.column == v.column == 1  # u, v should be column vector

          # Calculate
          _a    	=				v.transpose()
          _a    	=				(v_t * self * u)[0, 0] + 1
          if numerator_factor == 0:
               return None  # It's not invertable
          return self - ((self * u) * (v_t * self) * (1.0 / numerator_factor))


# Testing
if __name__ == "__main__":
   def       A_   (   ):






        """simple docstring"""

        _a    	=				Matrix(3,     3,     0       )
        for i in range(3       ):
             _a    	=				1
        print(f'a^(-1) is {ainv}'       )
        # u, v
        _a    	=				Matrix(3,     1,     0       )
        _a	,      _a	,      _a    	=				1, 2, -3
        _a    	=				Matrix(3,     1,     0       )
        _a	,      _a	,      _a    	=				4, -2, 5
        print(f'u is {u}'       )
        print(f'v is {v}'       )
        print(f'uv^T is {u * v.transpose()}'       )
        # Sherman Morrison
        print(f'(a + uv^T)^(-1) is {ainv.sherman_morrison(_lowerCAmelCase,     _lowerCAmelCase       )}'       )
   def       A_   (   ):






        """simple docstring"""

        import doctest

        doctest.testmod()

   testa()



"""simple docstring"""






def       A_   (   _lowerCAmelCase     :					Dict=2_81_23       ):






     """simple docstring"""

     _a    	=				[1] * (limit + 1)

     for i in range(2,     int(limit**0.5       ) + 1       ):
          sum_divs[i * i] += i
          for k in range(i + 1,     limit // i + 1       ):
               sum_divs[k * i] += k + i

     _a    	=				set()
     _a    	=				0

     for n in range(1,     limit + 1       ):
          if sum_divs[n] > n:
               abundants.add(_lowerCAmelCase       )

          if not any((n - a in abundants) for a in abundants       ):
               res += n

     return res


if __name__ == "__main__":
   print(solution())