






import math



def  __lowerCamelCase					(					lowerCAmelCase__				):
				A__							 =       [True] * n
				A__							 =       False
				A__							 =       False
				A__							 =       True

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

				A__							 =       [2]

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

				return primes



def  __lowerCamelCase					(					lowerCAmelCase__ = 9999_6666_3333				):
				A__							 =       math.floor(math.sqrt(lowerCAmelCase__				)				) + 100
				A__							 =       prime_sieve(lowerCAmelCase__				)

				A__							 =       0
				A__							 =       0
				A__							 =       primes[prime_index]

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

								A__							 =       last_prime**2
								A__							 =       next_prime**2

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

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

				return matches_sum


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










"""simple docstring"""






from ...processing_utils import ProcessorMixin





class       snake_case_       (    _lowerCamelCase       ):



	"""simple docstring"""

	SCREAMING_SNAKE_CASE_:							Union[str, Any]   			=					["""image_processor""", """feature_extractor"""]
	SCREAMING_SNAKE_CASE_:							Optional[int]   			=					"""TvltImageProcessor"""
	SCREAMING_SNAKE_CASE_:							Optional[int]   			=					"""TvltFeatureExtractor"""


	def __init__(      self  ,					__a  ,					__a						):


					"""simple docstring"""

					super().__init__(image_processor=__a  ,					feature_extractor=__a						)

					A__							 =       image_processor
					A__							 =       feature_extractor


	def __call__(      self  ,					__a=None  ,					__a=None  ,					__a=None  ,					__a=None  ,					__a=False  ,					__a=False  ,					*__a  ,					**__a  ,					):


					"""simple docstring"""

					if images is None and audio is None:
									raise ValueError('You need to specify either an `images` or `audio` input to process.'						)

					A__							 =       None
					if images is not None:
									A__							 =       self.image_processor(__a  ,					mask_pixel=__a  ,					*__a  ,					**__a						)
					if images_mixed is not None:
									A__							 =       self.image_processor(__a  ,					is_mixed=__a  ,					*__a  ,					**__a						)
					if audio is not None:
									A__							 =       self.feature_extractor(
									    __a  ,					*__a  ,					sampling_rate=__a  ,					mask_audio=__a  ,					**__a						)

					A__							 =       {}
					if audio is not None:
									output_dict.update(__a						)
					if images is not None:
									output_dict.update(__a						)
					if images_mixed_dict is not None:
									output_dict.update(__a						)
					return output_dict






	@property
	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__							 =       self.image_processor.model_input_names
					A__							 =       self.feature_extractor.model_input_names
					return list(dict.fromkeys(image_processor_input_names + feature_extractor_input_names						)						)


