


from math import isqrt, loga





def   _UpperCAmelCase       (     UpperCAmelCase      :			int      ):
      """simple docstring"""




      __lowerCamelCase     :      List[Any]       						=						[True] * max_number
      for i in range(2						,	isqrt(max_number - 1      ) + 1      ):
            if is_prime[i]:
                  for j in range(i**2						,	UpperCAmelCase						,	UpperCAmelCase      ):
                        __lowerCamelCase     :      Union[str, Any]       						=						False

      return [i for i in range(2						,	UpperCAmelCase      ) if is_prime[i]]





def   _UpperCAmelCase       (     UpperCAmelCase      :			int = 800_800						,	UpperCAmelCase      :			int = 800_800      ):
      """simple docstring"""




      __lowerCamelCase     :      Union[str, Any]       						=						degree * loga(UpperCAmelCase      )
      __lowerCamelCase     :      Tuple       						=						int(UpperCAmelCase      )
      __lowerCamelCase     :      Union[str, Any]       						=						calculate_prime_numbers(UpperCAmelCase      )

      __lowerCamelCase     :      str       						=						0
      __lowerCamelCase     :      Optional[int]       						=						0
      __lowerCamelCase     :      str       						=						len(UpperCAmelCase      ) - 1
      while left < right:
            while (
                prime_numbers[right] * loga(prime_numbers[left]      )
                + prime_numbers[left] * loga(prime_numbers[right]      )
                > upper_bound
            ):
                  right -= 1
            hybrid_integers_count += right - left
            left += 1

      return hybrid_integers_count


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







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__UpperCamelCase    :						Any     =							{
    'configuration_timesformer': ['TIMESFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP', 'TimesformerConfig'],
}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __UpperCamelCase    :						int     =							[
        'TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
        'TimesformerModel',
        'TimesformerForVideoClassification',
        'TimesformerPreTrainedModel',
    ]

if TYPE_CHECKING:
    from .configuration_timesformer import TIMESFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP, TimesformerConfig

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_timesformer import (
            TIMESFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
            TimesformerForVideoClassification,
            TimesformerModel,
            TimesformerPreTrainedModel,
        )

else:
    import sys

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



