
"""simple docstring"""







import math
def 	__UpperCamelCase (       SCREAMING_SNAKE_CASE			)	->  list:







							"""simple docstring"""


							__snake_case        =							[True] * n
							__snake_case        =							False
							__snake_case        =							False
							__snake_case        =							True

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

							__snake_case        =							[2]

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

							return primes
def 	__UpperCamelCase (       SCREAMING_SNAKE_CASE = 99_99_66_66_33_33			)	->  int:







							"""simple docstring"""


							__snake_case        =							math.floor(math.sqrt(_UpperCamelCase			)			) + 1_00
							__snake_case        =							prime_sieve(_UpperCamelCase			)

							__snake_case        =							0
							__snake_case        =							0
							__snake_case        =							primes[prime_index]

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

														__snake_case        =							last_prime**2
														__snake_case        =							next_prime**2

														# Get numbers divisible by lps(current)
														__snake_case        =							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        =							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        =							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        =							next_prime
														prime_index += 1

							return matches_sum


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








__magic_name__   :  Optional[Any]        =							0  # The first color of the flag.
__magic_name__   :  List[str]        =							1  # The second color of the flag.
__magic_name__   :  Dict        =							2  # The third color of the flag.
__magic_name__   :  Union[str, Any]        =							(red, white, blue)
def 		lowercase__  (				_UpperCamelCase) ->			list:
      """simple docstring"""

      if not sequence:
            return []
      if len(_UpperCamelCase) == 1:
            return list(_UpperCamelCase)
      UpperCamelCase					       =  0
      UpperCamelCase					       =  len(_UpperCamelCase) - 1
      UpperCamelCase					       =  0
      while mid <= high:
            if sequence[mid] == colors[0]:
                  UpperCamelCase       ,  UpperCamelCase					       =  sequence[mid], sequence[low]
                  low += 1
                  mid += 1
            elif sequence[mid] == colors[1]:
                  mid += 1
            elif sequence[mid] == colors[2]:
                  UpperCamelCase       ,  UpperCamelCase					       =  sequence[high], sequence[mid]
                  high -= 1
            else:
                  UpperCamelCase					       =  F'The elements inside the sequence must contains only {colors} values'
                  raise ValueError(_UpperCamelCase)
      return sequence


if __name__ == "__main__":
       import doctest

       doctest.testmod()

       __magic_name__   :  str        =							input('''Enter numbers separated by commas:\n''').strip()
       __magic_name__   :  Union[str, Any]        =							[int(item.strip()) for item in user_input.split(''',''')]
       print(F'{dutch_national_flag_sort(unsorted)}')



