





import math






def 					lowerCamelCase_						(    _UpperCamelCase			)		->						list:






				"""simple docstring"""


				snake_case_						:   int           =  [True] * n
				snake_case_						:   List[Any]           =  False
				snake_case_						:   int           =  False
				snake_case_						:   str           =  True

				for i in range(3			,    int(n**0.5 + 1			)			,    2			):
								snake_case_						:   int           =  i * 2
								while index < n:
												snake_case_						:   Optional[Any]           =  False
												snake_case_						:   Any           =  index + i

				snake_case_						:   Tuple           =  [2]

				for i in range(3			,    _UpperCamelCase			,    2			):
								if is_prime[i]:
												primes.append(_UpperCamelCase			)

				return primes






def 					lowerCamelCase_						(    _UpperCamelCase = 999_966_663_333			)		->						int:






				"""simple docstring"""


				snake_case_						:   str           =  math.floor(math.sqrt(_UpperCamelCase			)			) + 100
				snake_case_						:   str           =  prime_sieve(_UpperCamelCase			)

				snake_case_						:   int           =  0
				snake_case_						:   Tuple           =  0
				snake_case_						:   int           =  primes[prime_index]

				while (last_prime**2) <= limit:
								snake_case_						:   Tuple           =  primes[prime_index + 1]

								snake_case_						:   Union[str, Any]           =  last_prime**2
								snake_case_						:   str           =  next_prime**2

								# Get numbers divisible by lps(current)
								snake_case_						:   Optional[Any]           =  lower_bound + last_prime
								while upper_bound > current <= limit:
												matches_sum += current
												current += last_prime

								# Reset the upper_bound
								while (upper_bound - next_prime) > limit:
												upper_bound -= next_prime

								# Add the numbers divisible by ups(current)
								snake_case_						:   Tuple           =  upper_bound - next_prime
								while current > lower_bound:
												matches_sum += current
												current -= next_prime

								# Remove the numbers divisible by both ups and lps
								snake_case_						:   Dict           =  0
								while upper_bound > current <= limit:
												if current <= lower_bound:
																# Increment the current number
																current += last_prime * next_prime
																continue

												if current > limit:
																break

												# Remove twice since it was added by both ups and lps
												matches_sum -= current * 2

												# Increment the current number
												current += last_prime * next_prime

								# Setup for next pair
								snake_case_						:   Dict           =  next_prime
								prime_index += 1

				return matches_sum


if __name__ == "__main__":
	print(solution())







import random

from .binary_exp_mod import bin_exp_mod






def 					lowerCamelCase_						(    _UpperCamelCase			,    _UpperCamelCase=1_000			)		->						str:






				"""simple docstring"""


				if n < 2:
								return False

				if n % 2 == 0:
								return n == 2

				# this means n is odd
				snake_case_						:   int           =  n - 1
				snake_case_						:   Union[str, Any]           =  0
				while d % 2 == 0:
								d /= 2
								exp += 1

				# n - 1=d*(2**exp)
				snake_case_						:   List[Any]           =  0
				while count < prec:
								snake_case_						:   Tuple           =  random.randint(2			,    n - 1			)
								snake_case_						:   List[Any]           =  bin_exp_mod(_UpperCamelCase			,    _UpperCamelCase			,    _UpperCamelCase			)
								if b != 1:
												snake_case_						:   Any           =  True
												for _ in range(_UpperCamelCase			):
																if b == n - 1:
																				snake_case_						:   Tuple           =  False
																				break
																snake_case_						:   List[Any]           =  b * b
																b %= n
												if flag:
																return False
												count += 1
				return True


if __name__ == "__main__":
	lowerCAmelCase_    =    abs(int(input('''Enter bound : ''').strip()))
	print('''Here\'s the list of primes:''')
	print(''', '''.join(str(i) for i in range(n + 1) if is_prime_big(i)))
