




'''simple docstring'''




from __future__ import annotations

from collections.abc import Iterator
from typing import Generic, TypeVar

lowercase__  							=					TypeVar('''T''')






class      UpperCAmelCase_     (  Generic[T]     ):


	"""simple docstring"""


	def __init__(						self						, UpperCAmelCase_				):
						snake_case_	=      data
						snake_case_	=      None







	def __str__(						self				):
						return f'''{self.data}'''






class      UpperCAmelCase_     (  Generic[T]     ):


	"""simple docstring"""


	def __init__(						self				):
						snake_case_	=      None







	def __iter__(						self				):
						snake_case_	=      self.top
						while node:
											yield node.data
											snake_case_	=      node.next







	def __str__(						self				):
						return "->".join([str(UpperCamelCase__				) for item in self]				)







	def __len__(						self				):
						return len(tuple(iter(self				)				)				)







	def  _lowercase    (						self				):
						return self.top is None







	def  _lowercase    (						self						, UpperCAmelCase_				):
						snake_case_	=      Node(UpperCamelCase__				)
						if not self.is_empty():
											snake_case_	=      self.top
						snake_case_	=      node







	def  _lowercase    (						self				):


						if self.is_empty():
											raise IndexError("pop from empty stack"				)
						assert isinstance(self.top						, UpperCamelCase__				)
						snake_case_	=      self.top
						snake_case_	=      self.top.next
						return pop_node.data







	def  _lowercase    (						self				):


						if self.is_empty():
											raise IndexError("peek from empty stack"				)

						assert self.top is not None
						return self.top.data







	def  _lowercase    (						self				):
						snake_case_	=      None


if __name__ == "__main__":
					from doctest import testmod

					testmod()













'''simple docstring'''







from math import isqrt, loga


def       __UpperCamelCase					(      lowercase_       :  int   ):
       """simple docstring"""




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

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


def       __UpperCamelCase					(      lowercase_       :  int = 800_800   ,       lowercase_       :  int = 800_800   ):
       """simple docstring"""




       a_						     =			degree * loga(lowercase_   )
       a_						     =			int(lowercase_   )
       a_						     =			calculate_prime_numbers(lowercase_   )

       a_						     =			0
       a_						     =			0
       a_						     =			len(lowercase_   ) - 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() = }""")




