import math




def       _snake_case	(   lowerCAmelCase							:   int	):
		"""simple docstring"""







		SCREAMING_SNAKE_CASE_  :		List[Any]				      =    [True] * n
		SCREAMING_SNAKE_CASE_  :		Dict				      =    False
		SCREAMING_SNAKE_CASE_  :		Any				      =    False
		SCREAMING_SNAKE_CASE_  :		str				      =    True

		for i in range(3   , int(n**0.5 + 1	)   , 2	):
				SCREAMING_SNAKE_CASE_  :		Any				      =    i * 2
				while index < n:
						SCREAMING_SNAKE_CASE_  :		str				      =    False
						SCREAMING_SNAKE_CASE_  :		Any				      =    index + i

		SCREAMING_SNAKE_CASE_  :		Dict				      =    [2]

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

		return primes




def       _snake_case	(   lowerCAmelCase							:   int = 9_9_9_9_6_6_6_6_3_3_3_3	):
		"""simple docstring"""







		SCREAMING_SNAKE_CASE_  :		Dict				      =    math.floor(math.sqrt(lowerCAmelCase	)	) + 1_0_0
		SCREAMING_SNAKE_CASE_  :		List[str]				      =    prime_sieve(lowerCAmelCase	)

		SCREAMING_SNAKE_CASE_  :		Tuple				      =    0
		SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    0
		SCREAMING_SNAKE_CASE_  :		Tuple				      =    primes[prime_index]

		while (last_prime**2) <= limit:
				SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    primes[prime_index + 1]

				SCREAMING_SNAKE_CASE_  :		Dict				      =    last_prime**2
				SCREAMING_SNAKE_CASE_  :		Dict				      =    next_prime**2

				# Get numbers divisible by lps(current)
				SCREAMING_SNAKE_CASE_  :		str				      =    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)
				SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    upper_bound - next_prime
				while current > lower_bound:
						matches_sum += current
						current -= next_prime

				# Remove the numbers divisible by both ups and lps
				SCREAMING_SNAKE_CASE_  :		List[Any]				      =    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
				SCREAMING_SNAKE_CASE_  :		List[str]				      =    next_prime
				prime_index += 1

		return matches_sum


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




def        _lowerCamelCase(	lowercase__   , lowercase__ = " "	)						->	list:

		'''simple docstring'''







		__lowercase=			[]

		__lowercase=			0
		for index, char in enumerate(lowercase__	):
				if char == separator:
						split_words.append(string[last_index:index]	)
						__lowercase=			index + 1
				elif index + 1 == len(lowercase__	):
						split_words.append(string[last_index : index + 1]	)
		return split_words


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

	testmod()






