



"""simple docstring"""
from timeit import timeit

def       _snake_case						(						UpperCamelCase						:		int						):
 if number < 0:
  raise ValueError("""the value of input must not be negative"""						)
 UpperCAmelCase	:					Union[str, Any]	=	0
 while number:
  number &= number - 1
  result += 1
 return result

def       _snake_case						(						UpperCamelCase						:		int						):
 if number < 0:
  raise ValueError("""the value of input must not be negative"""						)
 UpperCAmelCase	:					Tuple	=	0
 while number:
  if number % 2 == 1:
   result += 1
  number >>= 1
 return result

def       _snake_case						(						):

 def do_benchmark(UpperCamelCase						:		int						) -> None:
  UpperCAmelCase	:					Optional[int]	=	"""import __main__ as z"""
  print(F"Benchmark when {number = }:"						)
  print(F"{get_set_bits_count_using_modulo_operator(snake_case__						) = }"						)
  UpperCAmelCase	:					Any	=	timeit("""z.get_set_bits_count_using_modulo_operator(25)"""			,		setup=snake_case__						)
  print(F"timeit() runs in {timing} seconds"						)
  print(F"{get_set_bits_count_using_brian_kernighans_algorithm(snake_case__						) = }"						)
  UpperCAmelCase	:					int	=	timeit(
      """z.get_set_bits_count_using_brian_kernighans_algorithm(25)"""			,		setup=snake_case__			,		)
  print(F"timeit() runs in {timing} seconds"						)

 for number in (25, 37, 58, 0):
  do_benchmark(snake_case__						)
  print()


if __name__ == "__main__":
      import doctest

      doctest.testmod()
      benchmark()

from math import isqrt, loga






def  snake_case  (       snake_case__			:int)						->   list[int]:
       _A        =  [True] * max_number
       for i in range(2   ,	isqrt(max_number - 1) + 1):
              if is_prime[i]:
                     for j in range(i**2   ,	snake_case__   ,	snake_case__):
                            _A        =  False

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






def  snake_case  (       snake_case__			:int = 800_800   ,	snake_case__			:int = 800_800)						->   int:
       _A        =  degree * loga(snake_case__)
       _A        =  int(snake_case__)
       _A        =  calculate_prime_numbers(snake_case__)

       _A        =  0
       _A        =  0
       _A        =  len(snake_case__) - 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() = }''')




