



'''simple docstring'''




from math import isqrt, loga



def    __lowerCamelCase						(      _lowercase	)   ->    list[int]:
							UpperCAmelCase  :	Optional[int]							  =	[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	):
																												UpperCAmelCase  :	Union[str, Any]							  =	False

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



def    __lowerCamelCase						(      _lowercase = 8_0_0_8_0_0			,       _lowercase = 8_0_0_8_0_0	)   ->    int:
							UpperCAmelCase  :	int							  =	degree * loga(_lowercase	)
							UpperCAmelCase  :	Dict							  =	int(_lowercase	)
							UpperCAmelCase  :	List[str]							  =	calculate_prime_numbers(_lowercase	)

							UpperCAmelCase  :	int							  =	0
							UpperCAmelCase  :	int							  =	0
							UpperCAmelCase  :	List[str]							  =	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() = }''')






'''simple docstring'''




from collections.abc import Callable

import numpy as np



def    __lowerCamelCase						(      _lowercase			,       _lowercase			,       _lowercase			,       _lowercase			,       _lowercase	)   ->    np.array:
							UpperCAmelCase  :	Optional[Any]							  =	int(np.ceil((x_end - xa) / step_size	)	)
							UpperCAmelCase  :	str							  =	np.zeros((n + 1,)	)
							UpperCAmelCase  :	Optional[Any]							  =	ya
							UpperCAmelCase  :	Union[str, Any]							  =	xa

							for k in range(_lowercase	):
														UpperCAmelCase  :	Dict							  =	y[k] + step_size * ode_func(_lowercase			,       y[k]	)
														UpperCAmelCase  :	Optional[int]							  =	y[k] + (
														    (step_size / 2) * (ode_func(_lowercase			,       y[k]	) + ode_func(x + step_size			,       _lowercase	))
														)
														x += step_size

							return y


if __name__ == "__main__":
							import doctest

							doctest.testmod()

