

import math
from collections.abc import Generator




def        __UpperCamelCase     (      _A					:							int		)				->Generator[int, None, None]:



							"""simple docstring"""
							lowerCamelCase_								=(i for i in range(1      ,  (max_n + 1)		))
							for i in (n for n in numbers if n > 1):
														for j in range(2      ,  _A		):
																					if (i % j) == 0:
																												break
														else:
																					yield i




def        __UpperCamelCase     (      _A					:							int		)				->Generator[int, None, None]:



							"""simple docstring"""
							lowerCamelCase_								=(i for i in range(1      ,  (max_n + 1)		))
							for i in (n for n in numbers if n > 1):
														# only need to check for factors up to sqrt(i)
														lowerCamelCase_								=int(math.sqrt(_A		)		) + 1
														for j in range(2      ,  _A		):
																					if (i % j) == 0:
																												break
														else:
																					yield i




def        __UpperCamelCase     (      _A					:							int		)				->Generator[int, None, None]:



							"""simple docstring"""
							lowerCamelCase_								=(i for i in range(1      ,  (max_n + 1)      ,  2		))
							# It's useless to test even numbers as they will not be prime
							if max_n > 2:
														yield 2  # Because 2 will not be tested, it's necessary to yield it now
							for i in (n for n in numbers if n > 1):
														lowerCamelCase_								=int(math.sqrt(_A		)		) + 1
														for j in range(3      ,  _A      ,  2		):
																					# As we removed the even numbers, we don't need them now
																					if (i % j) == 0:
																												break
														else:
																					yield i




def        __UpperCamelCase     (      )				->Dict:



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

							lowerCamelCase_								="""from __main__ import slow_primes, primes, fast_primes"""
							print(timeit("""slow_primes(1_000_000_000_000)"""      ,  setup=_A      ,  number=1000000		)		)
							print(timeit("""primes(1_000_000_000_000)"""      ,  setup=_A      ,  number=1000000		)		)
							print(timeit("""fast_primes(1_000_000_000_000)"""      ,  setup=_A      ,  number=1000000		)		)


if __name__ == "__main__":
	__A	:   Union[str, Any]	=					int(input('Calculate primes up to:\n>> ').strip())
	for ret in primes(number):
		print(ret)
	benchmark()



from __future__ import annotations




def        __UpperCamelCase     (      _A					:							int      ,  _A					:							list[int]      ,  _A					:							list[int]      ,  _A					:							int		)				->int:



							"""simple docstring"""

							# Base Case
							if counter == 0 or capacity == 0:
														return 0

							# If weight of the nth item is more than Knapsack of capacity,
							#   then this item cannot be included in the optimal solution,
							# else return the maximum of two cases:
							#   (1) nth item included
							#   (2) not included
							if weights[counter - 1] > capacity:
														return knapsack(_A      ,  _A      ,  _A      ,  counter - 1		)
							else:
														lowerCamelCase_								=capacity - weights[counter - 1]
														lowerCamelCase_								=values[counter - 1] + knapsack(
														    _A      ,  _A      ,  _A      ,  counter - 1		)
														lowerCamelCase_								=knapsack(_A      ,  _A      ,  _A      ,  counter - 1		)
														return max(_A      ,  _A		)


if __name__ == "__main__":
	import doctest

	doctest.testmod()
