
import math






def 				UpperCAmelCase_						(				__SCREAMING_SNAKE_CASE				):
	lowercase	    =       [True] * n
	lowercase	    =       False
	lowercase	    =       False
	lowercase	    =       True

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

	lowercase	    =       [2]

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

	return primes






def 				UpperCAmelCase_						(				__SCREAMING_SNAKE_CASE = 9999_6666_3333				):
	lowercase	    =       math.floor(math.sqrt(__SCREAMING_SNAKE_CASE				)				) + 100
	lowercase	    =       prime_sieve(__SCREAMING_SNAKE_CASE				)

	lowercase	    =       0
	lowercase	    =       0
	lowercase	    =       primes[prime_index]

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

		lowercase	    =       last_prime**2
		lowercase	    =       next_prime**2

		# Get numbers divisible by lps(current)
		lowercase	    =       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)
		lowercase	    =       upper_bound - next_prime
		while current > lower_bound:
			matches_sum += current
			current -= next_prime

		# Remove the numbers divisible by both ups and lps
		lowercase	    =       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
		lowercase	    =       next_prime
		prime_index += 1

	return matches_sum


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





from ..utils import DummyObject, requires_backends







class        __lowercase       (							metaclass=a_  ):



		"""simple docstring"""

		UpperCamelCase     :					Tuple			       =		["flax"]







		def __init__( self		,      *A		,      **A	)  -> str:







					'''simple docstring'''







					requires_backends(self		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> int:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> str:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







class        __lowercase       (							metaclass=a_  ):



		"""simple docstring"""

		UpperCamelCase     :					Optional[Any]			       =		["flax"]







		def __init__( self		,      *A		,      **A	)  -> Dict:







					'''simple docstring'''







					requires_backends(self		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> List[str]:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Dict:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







class        __lowercase       (							metaclass=a_  ):



		"""simple docstring"""

		UpperCamelCase     :					str			       =		["flax"]







		def __init__( self		,      *A		,      **A	)  -> Dict:







					'''simple docstring'''







					requires_backends(self		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Union[str, Any]:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Optional[int]:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







class        __lowercase       (							metaclass=a_  ):



		"""simple docstring"""

		UpperCamelCase     :					str			       =		["flax"]







		def __init__( self		,      *A		,      **A	)  -> List[Any]:







					'''simple docstring'''







					requires_backends(self		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Any:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Union[str, Any]:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







class        __lowercase       (							metaclass=a_  ):



		"""simple docstring"""

		UpperCamelCase     :					Dict			       =		["flax"]







		def __init__( self		,      *A		,      **A	)  -> Optional[Any]:







					'''simple docstring'''







					requires_backends(self		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Optional[Any]:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Any:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







class        __lowercase       (							metaclass=a_  ):



		"""simple docstring"""

		UpperCamelCase     :					Optional[int]			       =		["flax"]







		def __init__( self		,      *A		,      **A	)  -> int:







					'''simple docstring'''







					requires_backends(self		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> int:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> str:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







class        __lowercase       (							metaclass=a_  ):



		"""simple docstring"""

		UpperCamelCase     :					Union[str, Any]			       =		["flax"]







		def __init__( self		,      *A		,      **A	)  -> List[Any]:







					'''simple docstring'''







					requires_backends(self		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Tuple:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Optional[int]:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







class        __lowercase       (							metaclass=a_  ):



		"""simple docstring"""

		UpperCamelCase     :					Optional[Any]			       =		["flax"]







		def __init__( self		,      *A		,      **A	)  -> Optional[Any]:







					'''simple docstring'''







					requires_backends(self		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> int:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> int:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







class        __lowercase       (							metaclass=a_  ):



		"""simple docstring"""

		UpperCamelCase     :					Tuple			       =		["flax"]







		def __init__( self		,      *A		,      **A	)  -> str:







					'''simple docstring'''







					requires_backends(self		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> List[Any]:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> str:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







class        __lowercase       (							metaclass=a_  ):



		"""simple docstring"""

		UpperCamelCase     :					Any			       =		["flax"]







		def __init__( self		,      *A		,      **A	)  -> List[str]:







					'''simple docstring'''







					requires_backends(self		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> int:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> str:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







class        __lowercase       (							metaclass=a_  ):



		"""simple docstring"""

		UpperCamelCase     :					str			       =		["flax"]







		def __init__( self		,      *A		,      **A	)  -> Dict:







					'''simple docstring'''







					requires_backends(self		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Optional[int]:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Dict:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







class        __lowercase       (							metaclass=a_  ):



		"""simple docstring"""

		UpperCamelCase     :					Optional[int]			       =		["flax"]







		def __init__( self		,      *A		,      **A	)  -> List[str]:







					'''simple docstring'''







					requires_backends(self		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Any:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Any:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







class        __lowercase       (							metaclass=a_  ):



		"""simple docstring"""

		UpperCamelCase     :					Tuple			       =		["flax"]







		def __init__( self		,      *A		,      **A	)  -> str:







					'''simple docstring'''







					requires_backends(self		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Dict:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)







		@classmethod
		def 					__A   ( cls		,      *A		,      **A	)  -> Union[str, Any]:







					'''simple docstring'''







					requires_backends(cls		,      ["""flax"""]	)

