





def 	lowerCamelCase_		(							_UpperCamelCase = 50_000_000					)						->		int:






				"""simple docstring"""


				snake_case_		:       Optional[Any]           =    set()
				snake_case_		:       List[Any]           =    int((limit - 24) ** (1 / 2)					)

				snake_case_		:       Any           =    set(range(3					,							prime_square_limit + 1					,							2					)					)
				primes.add(2					)
				for p in range(3					,							prime_square_limit + 1					,							2					):
								if p not in primes:
												continue
								primes.difference_update(set(range(p * p					,							prime_square_limit + 1					,							__snake_case					)					)					)

				for primea in primes:
								snake_case_		:       str           =    primea * primea
								for primea in primes:
												snake_case_		:       Union[str, Any]           =    primea * primea * primea
												if square + cube >= limit - 16:
																break
												for primea in primes:
																snake_case_		:       List[Any]           =    primea * primea * primea * primea
																snake_case_		:       int           =    square + cube + tetr
																if total >= limit:
																				break
																ret.add(__snake_case					)

				return len(__snake_case					)


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








from __future__ import annotations
class 		SCREAMING_SNAKE_CASE__	:

  '''simple docstring'''







  def __init__(      self		:			Optional[Any]       ,				lowerCamelCase		:			list[list[int]]							)						->	Any:


         """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(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		:			Optional[Any]							)						->	list[list[int]]:


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


  @property
  def  lowerCamelCase       (      self		:			int							)						->	int:


         """simple docstring"""
         return len(self.rows							)


  @property
  def  lowerCamelCase       (      self		:			int							)						->	int:


         """simple docstring"""
         return len(self.rows[0]							)


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


         """simple docstring"""
         return (self.num_rows, self.num_columns)


  @property
  def  lowerCamelCase       (      self		:			Tuple							)						->	bool:


         """simple docstring"""
         return self.order[0] == self.order[1]


  def  lowerCamelCase       (      self		:			Optional[int]							)						->	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(lowerCamelCase							)


  def  lowerCamelCase       (      self		:			Optional[Any]							)						->	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  lowerCamelCase       (      self		:			Optional[Any]							)						->	bool:


         """simple docstring"""
         return bool(self.determinant()							)


  def  lowerCamelCase       (      self		:			Tuple       ,				lowerCamelCase		:			int       ,				lowerCamelCase		:			int							)						->	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(lowerCamelCase							).determinant()


  def  lowerCamelCase       (      self		:			int       ,				lowerCamelCase		:			int       ,				lowerCamelCase		:			int							)						->	int:


         """simple docstring"""
         if (row + column) % 2 == 0:
                return self.get_minor(lowerCamelCase       ,				lowerCamelCase							)
         return -1 * self.get_minor(lowerCamelCase       ,				lowerCamelCase							)


  def  lowerCamelCase       (      self		:			str							)						->	Matrix:


         """simple docstring"""
         return Matrix(
             [
                 [self.get_minor(lowerCamelCase       ,				lowerCamelCase							) for column in range(self.num_columns							)]
                 for row in range(self.num_rows							)
             ]							)


  def  lowerCamelCase       (      self		:			Dict							)						->	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  lowerCamelCase       (      self		:			Optional[Any]							)						->	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(lowerCamelCase							)


  def  lowerCamelCase       (      self		:			Any							)						->	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		:			List[str]							)						->	str:


         """simple docstring"""
         return str(self.rows							)


  def __str__(      self		:			Optional[Any]							)						->	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(lowerCamelCase							) for value in row]							) + """.]"""
                     for row in self.rows
                 ]							)
             + "]"
         )


  def  lowerCamelCase       (      self		:			Tuple       ,				lowerCamelCase		:			list[int]       ,				lowerCamelCase		:			int | None = None							)						->	None:


         """simple docstring"""
         _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		:			List[Any]       ,				lowerCamelCase		:			list[int]       ,				lowerCamelCase		:			int | None = None							)						->	None:


         """simple docstring"""
         _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		:			Dict       ,				lowerCamelCase		:			object							)						->	bool:


         """simple docstring"""
         if not isinstance(lowerCamelCase       ,				lowerCamelCase							):
                return NotImplemented
         return self.rows == other.rows


  def __ne__(      self		:			List[str]       ,				lowerCamelCase		:			object							)						->	bool:


         """simple docstring"""
         return not self == other


  def __neg__(      self		:			Union[str, Any]							)						->	Matrix:


         """simple docstring"""
         return self * -1


  def __add__(      self		:			Any       ,				lowerCamelCase		:			Matrix							)						->	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		:			Optional[Any]       ,				lowerCamelCase		:			Matrix							)						->	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		:			List[Any]       ,				lowerCamelCase		:			Matrix | int | float							)						->	Matrix:


         """simple docstring"""
         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		:			Any       ,				lowerCamelCase		:			int							)						->	Matrix:


         """simple docstring"""
         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		:			Tuple       ,				lowerCamelCase		:			list[int]       ,				lowerCamelCase		:			list[int]							)						->	int:


         """simple docstring"""
         return sum(row[i] * column[i] for i in range(len(lowerCamelCase							)							)							)


if __name__ == "__main__":
  import doctest

  doctest.testmod()