


def 			_a  (				SCREAMING_SNAKE_CASE	:				int = 50000000     ):







	"""simple docstring"""



	UpperCamelCase__					:    int          =   set()
	UpperCamelCase__					:    Union[str, Any]          =   int((limit - 24) ** (1 / 2)     )

	UpperCamelCase__					:    Optional[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    , a_     )     )     )

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

	return len(a_     )


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






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


__UpperCamelCase       :       Optional[int]						       =				{
    "configuration_rag": ["RagConfig"],
    "retrieval_rag": ["RagRetriever"],
    "tokenization_rag": ["RagTokenizer"],
}

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __UpperCamelCase       :       Optional[int]						       =				[
           "RagModel",
           "RagPreTrainedModel",
           "RagSequenceForGeneration",
           "RagTokenForGeneration",
       ]

try:
       if not is_tf_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __UpperCamelCase       :       List[Any]						       =				[
           "TFRagModel",
           "TFRagPreTrainedModel",
           "TFRagSequenceForGeneration",
           "TFRagTokenForGeneration",
       ]


if TYPE_CHECKING:
       from .configuration_rag import RagConfig
       from .retrieval_rag import RagRetriever
       from .tokenization_rag import RagTokenizer

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_rag import RagModel, RagPreTrainedModel, RagSequenceForGeneration, RagTokenForGeneration

       try:
              if not is_tf_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_tf_rag import (
                  TFRagModel,
                  TFRagPreTrainedModel,
                  TFRagSequenceForGeneration,
                  TFRagTokenForGeneration,
              )

else:
       import sys

       __UpperCamelCase       :       List[Any]						       =				_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)


