from ..utils import DummyObject, requires_backends




class 					_UpperCAmelCase			(     metaclass=lowerCAmelCase  ):



 '''simple docstring'''




 __A			       =					['''torch''', '''transformers''', '''onnx''']







 def __init__(		self				:   Optional[int]							, *lowercase_				:   str							, **lowercase_				:   str)						->	Optional[int]:


   """simple docstring"""







   requires_backends(self							, ["torch", "transformers", "onnx"])







 @classmethod
 def 		__UpperCAmelCase				(		cls				:   Any							, *lowercase_				:   Union[str, Any]							, **lowercase_				:   int)						->	Union[str, Any]:


   """simple docstring"""







   requires_backends(cls							, ["torch", "transformers", "onnx"])







 @classmethod
 def 		__UpperCAmelCase				(		cls				:   Dict							, *lowercase_				:   str							, **lowercase_				:   int)						->	Union[str, Any]:


   """simple docstring"""







   requires_backends(cls							, ["torch", "transformers", "onnx"])




class 					_UpperCAmelCase			(     metaclass=lowerCAmelCase  ):



 '''simple docstring'''




 __A			       =					['''torch''', '''transformers''', '''onnx''']







 def __init__(		self				:   Optional[Any]							, *lowercase_				:   Optional[Any]							, **lowercase_				:   Optional[int])						->	Union[str, Any]:


   """simple docstring"""







   requires_backends(self							, ["torch", "transformers", "onnx"])







 @classmethod
 def 		__UpperCAmelCase				(		cls				:   Dict							, *lowercase_				:   Any							, **lowercase_				:   Optional[Any])						->	Optional[Any]:


   """simple docstring"""







   requires_backends(cls							, ["torch", "transformers", "onnx"])







 @classmethod
 def 		__UpperCAmelCase				(		cls				:   int							, *lowercase_				:   str							, **lowercase_				:   Any)						->	Union[str, Any]:


   """simple docstring"""







   requires_backends(cls							, ["torch", "transformers", "onnx"])




class 					_UpperCAmelCase			(     metaclass=lowerCAmelCase  ):



 '''simple docstring'''




 __A			       =					['''torch''', '''transformers''', '''onnx''']







 def __init__(		self				:   str							, *lowercase_				:   int							, **lowercase_				:   str)						->	Tuple:


   """simple docstring"""







   requires_backends(self							, ["torch", "transformers", "onnx"])







 @classmethod
 def 		__UpperCAmelCase				(		cls				:   Optional[Any]							, *lowercase_				:   List[str]							, **lowercase_				:   Optional[Any])						->	Any:


   """simple docstring"""







   requires_backends(cls							, ["torch", "transformers", "onnx"])







 @classmethod
 def 		__UpperCAmelCase				(		cls				:   Dict							, *lowercase_				:   Dict							, **lowercase_				:   List[Any])						->	List[str]:


   """simple docstring"""







   requires_backends(cls							, ["torch", "transformers", "onnx"])




class 					_UpperCAmelCase			(     metaclass=lowerCAmelCase  ):



 '''simple docstring'''




 __A			       =					['''torch''', '''transformers''', '''onnx''']







 def __init__(		self				:   List[Any]							, *lowercase_				:   Union[str, Any]							, **lowercase_				:   int)						->	Optional[int]:


   """simple docstring"""







   requires_backends(self							, ["torch", "transformers", "onnx"])







 @classmethod
 def 		__UpperCAmelCase				(		cls				:   List[str]							, *lowercase_				:   Any							, **lowercase_				:   Tuple)						->	Any:


   """simple docstring"""







   requires_backends(cls							, ["torch", "transformers", "onnx"])







 @classmethod
 def 		__UpperCAmelCase				(		cls				:   Dict							, *lowercase_				:   List[Any]							, **lowercase_				:   Optional[int])						->	List[Any]:


   """simple docstring"""







   requires_backends(cls							, ["torch", "transformers", "onnx"])




class 					_UpperCAmelCase			(     metaclass=lowerCAmelCase  ):



 '''simple docstring'''




 __A			       =					['''torch''', '''transformers''', '''onnx''']







 def __init__(		self				:   str							, *lowercase_				:   int							, **lowercase_				:   Dict)						->	Tuple:


   """simple docstring"""







   requires_backends(self							, ["torch", "transformers", "onnx"])







 @classmethod
 def 		__UpperCAmelCase				(		cls				:   Tuple							, *lowercase_				:   Optional[int]							, **lowercase_				:   int)						->	Optional[Any]:


   """simple docstring"""







   requires_backends(cls							, ["torch", "transformers", "onnx"])







 @classmethod
 def 		__UpperCAmelCase				(		cls				:   List[str]							, *lowercase_				:   List[str]							, **lowercase_				:   List[str])						->	int:


   """simple docstring"""







   requires_backends(cls							, ["torch", "transformers", "onnx"])




class 					_UpperCAmelCase			(     metaclass=lowerCAmelCase  ):



 '''simple docstring'''




 __A			       =					['''torch''', '''transformers''', '''onnx''']







 def __init__(		self				:   Union[str, Any]							, *lowercase_				:   List[str]							, **lowercase_				:   List[str])						->	Tuple:


   """simple docstring"""







   requires_backends(self							, ["torch", "transformers", "onnx"])







 @classmethod
 def 		__UpperCAmelCase				(		cls				:   Optional[Any]							, *lowercase_				:   Union[str, Any]							, **lowercase_				:   int)						->	Optional[Any]:


   """simple docstring"""







   requires_backends(cls							, ["torch", "transformers", "onnx"])







 @classmethod
 def 		__UpperCAmelCase				(		cls				:   Tuple							, *lowercase_				:   Any							, **lowercase_				:   List[Any])						->	List[Any]:


   """simple docstring"""







   requires_backends(cls							, ["torch", "transformers", "onnx"])





from math import isqrt, loga


def 				lowerCAmelCase__       (			a__ )      ->list[int]:




  '''simple docstring'''

  _UpperCamelCase           =    [True] * max_number
  for i in range(2    ,     isqrt(max_number - 1 ) + 1 ):
    if is_prime[i]:
      for j in range(i**2    ,     a__    ,     a__ ):
        _UpperCamelCase           =    False

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


def 				lowerCAmelCase__       (			a__ = 800_800    ,     a__ = 800_800 )      ->int:




  '''simple docstring'''

  _UpperCamelCase           =    degree * loga(a__ )
  _UpperCamelCase           =    int(a__ )
  _UpperCamelCase           =    calculate_prime_numbers(a__ )

  _UpperCamelCase           =    0
  _UpperCamelCase           =    0
  _UpperCamelCase           =    len(a__ ) - 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() = }")




