


'''simple docstring'''


from __future__ import annotations

from typing import Any


def 		_lowercase   (*SCREAMING_SNAKE_CASE       ):




     '''simple docstring'''





     if all(_check_not_integer(SCREAMING_SNAKE_CASE       ) for m in matrix_s       ):
          for i in matrix_s[1:]:
               _verify_matrix_sizes(matrix_s[0]					,				SCREAMING_SNAKE_CASE       )
          return [[sum(SCREAMING_SNAKE_CASE       ) for t in zip(*SCREAMING_SNAKE_CASE       )] for m in zip(*SCREAMING_SNAKE_CASE       )]
     raise TypeError("Expected a matrix, got int/list instead"       )


def 		_lowercase   (SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE       ):




     '''simple docstring'''





     if (
         _check_not_integer(SCREAMING_SNAKE_CASE       )
         and _check_not_integer(SCREAMING_SNAKE_CASE       )
         and _verify_matrix_sizes(SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE       )
     ):
          return [[i - j for i, j in zip(*SCREAMING_SNAKE_CASE       )] for m in zip(SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE       )]
     raise TypeError("Expected a matrix, got int/list instead"       )


def 		_lowercase   (SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE       ):




     '''simple docstring'''





     return [[x * n for x in row] for row in matrix]


def 		_lowercase   (SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE       ):




     '''simple docstring'''





     if _check_not_integer(SCREAMING_SNAKE_CASE       ) and _check_not_integer(SCREAMING_SNAKE_CASE       ):
          __A  :					Union[str, Any]						     =       _verify_matrix_sizes(SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE       )

     if cols[0] != rows[1]:
          __A  :					Optional[int]						     =       (
              "Cannot multiply matrix of dimensions "
              f"({rows[0]},{cols[0]}) and ({rows[1]},{cols[1]})"
          )
          raise ValueError(SCREAMING_SNAKE_CASE       )
     return [
         [sum(m * n for m, n in zip(SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE       )       ) for j in zip(*SCREAMING_SNAKE_CASE       )] for i in matrix_a
     ]


def 		_lowercase   (SCREAMING_SNAKE_CASE       ):




     '''simple docstring'''





     __A  :					Optional[int]						     =       int(SCREAMING_SNAKE_CASE       )
     return [[int(row == column       ) for column in range(SCREAMING_SNAKE_CASE       )] for row in range(SCREAMING_SNAKE_CASE       )]


def 		_lowercase   (SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE = True       ):




     '''simple docstring'''





     if _check_not_integer(SCREAMING_SNAKE_CASE       ):
          if return_map:
               return map(SCREAMING_SNAKE_CASE					,				zip(*SCREAMING_SNAKE_CASE       )       )
          else:
               return list(map(SCREAMING_SNAKE_CASE					,				zip(*SCREAMING_SNAKE_CASE       )       )       )
     raise TypeError("Expected a matrix, got int/list instead"       )


def 		_lowercase   (SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE       ):




     '''simple docstring'''





     __A  :					Dict						     =       matrix[:row] + matrix[row + 1 :]
     return [row[:column] + row[column + 1 :] for row in minor]


def 		_lowercase   (SCREAMING_SNAKE_CASE       ):




     '''simple docstring'''





     if len(SCREAMING_SNAKE_CASE       ) == 1:
          return matrix[0][0]

     return sum(
         x * determinant(minor(SCREAMING_SNAKE_CASE					,				0					,				SCREAMING_SNAKE_CASE       )       ) * (-1) ** i
         for i, x in enumerate(matrix[0]       )       )


def 		_lowercase   (SCREAMING_SNAKE_CASE       ):




     '''simple docstring'''





     __A  :					int						     =       determinant(SCREAMING_SNAKE_CASE       )
     if det == 0:
          return None

     __A  :					List[str]						     =       [
         [determinant(minor(SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE       )       ) for j in range(len(SCREAMING_SNAKE_CASE       )       )]
         for i in range(len(SCREAMING_SNAKE_CASE       )       )
     ]

     __A  :					Union[str, Any]						     =       [
         [x * (-1) ** (row + col) for col, x in enumerate(matrix_minor[row]       )]
         for row in range(len(SCREAMING_SNAKE_CASE       )       )
     ]
     __A  :					int						     =       list(transpose(SCREAMING_SNAKE_CASE       )       )
     return scalar_multiply(SCREAMING_SNAKE_CASE					,				1 / det       )


def 		_lowercase   (SCREAMING_SNAKE_CASE       ):




     '''simple docstring'''





     return not isinstance(SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE       ) and not isinstance(matrix[0]					,				SCREAMING_SNAKE_CASE       )


def 		_lowercase   (SCREAMING_SNAKE_CASE       ):




     '''simple docstring'''





     return len(SCREAMING_SNAKE_CASE       ), len(matrix[0]       )


def 		_lowercase   (SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE       ):




     '''simple docstring'''





     __A  :					Union[str, Any]						     =       _shape(SCREAMING_SNAKE_CASE       ) + _shape(SCREAMING_SNAKE_CASE       )
     if shape[0] != shape[3] or shape[1] != shape[2]:
          __A  :					Tuple						     =       (
              "operands could not be broadcast together with shape "
              f"({shape[0], shape[1]}), ({shape[2], shape[3]})"
          )
          raise ValueError(SCREAMING_SNAKE_CASE       )
     return (shape[0], shape[2]), (shape[1], shape[3])


def 		_lowercase   ():




     '''simple docstring'''





     __A  :					Tuple						     =       [[12, 10], [3, 9]]
     __A  :					Dict						     =       [[3, 4], [7, 4]]
     __A  :					Optional[Any]						     =       [[11, 12, 13, 14], [21, 22, 23, 24], [31, 32, 33, 34], [41, 42, 43, 44]]
     __A  :					List[Any]						     =       [[3, 0, 2], [2, 0, -2], [0, 1, 1]]
     print(f"Add Operation, {add(SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE       ) = } \n"       )
     print(
         f"Multiply Operation, {multiply(SCREAMING_SNAKE_CASE					,				SCREAMING_SNAKE_CASE       ) = } \n"					,				)
     print(f"Identity: {identity(5       )}\n"       )
     print(f"Minor of {matrix_c} = {minor(SCREAMING_SNAKE_CASE					,				1					,				2       )} \n"       )
     print(f"Determinant of {matrix_b} = {determinant(SCREAMING_SNAKE_CASE       )} \n"       )
     print(f"Inverse of {matrix_d} = {inverse(SCREAMING_SNAKE_CASE       )}\n"       )


if __name__ == "__main__":
      import doctest

      doctest.testmod()
      main()





'''simple docstring'''


from collections import defaultdict


def 		_lowercase   (SCREAMING_SNAKE_CASE = 5       ):




     '''simple docstring'''





     __A  :					int						     =       defaultdict(SCREAMING_SNAKE_CASE       )
     __A  :					Optional[Any]						     =       0

     while True:
          __A  :					List[str]						     =       get_digits(SCREAMING_SNAKE_CASE       )
          freqs[digits].append(SCREAMING_SNAKE_CASE       )

          if len(freqs[digits]       ) == max_base:
               __A  :					Optional[int]						     =       freqs[digits][0] ** 3
               return base

          num += 1


def 		_lowercase   (SCREAMING_SNAKE_CASE       ):




     '''simple docstring'''





     return "".join(sorted(str(num**3       )       )       )


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

