
"""simple docstring"""



import math


def lowerCamelCase_				(     _lowerCamelCase			:	int				):
       lowerCamelCase_       							=		[True] * n
       lowerCamelCase_       							=		False
       lowerCamelCase_       							=		False
       lowerCamelCase_       							=		True

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

       lowerCamelCase_       							=		[2]

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

       return primes


def lowerCamelCase_				(     _lowerCamelCase			:	int = 9_9_9_9_6_6_6_6_3_3_3_3				):
       lowerCamelCase_       							=		math.floor(math.sqrt(_lowerCamelCase				)				) + 1_0_0
       lowerCamelCase_       							=		prime_sieve(_lowerCamelCase				)

       lowerCamelCase_       							=		0
       lowerCamelCase_       							=		0
       lowerCamelCase_       							=		primes[prime_index]

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

              lowerCamelCase_       							=		last_prime**2
              lowerCamelCase_       							=		next_prime**2

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

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

       return matches_sum


if __name__ == "__main__":
 print(solution())
def 	lowerCamelCase					(	UpperCamelCase     :				int = 60_08_51_47_51_43							)   ->    int:

		try:
				_lowerCamelCase				   =  int(UpperCamelCase							)
		except (TypeError, ValueError):
				raise TypeError('Parameter n must be int or castable to int.'							)
		if n <= 0:
				raise ValueError('Parameter n must be greater than or equal to one.'							)
		_lowerCamelCase				   =  1
		_lowerCamelCase				   =  2
		while i * i <= n:
				while n % i == 0:
						_lowerCamelCase				   =  i
						n //= i
				i += 1
		if n > 1:
				_lowerCamelCase				   =  n
		return int(UpperCamelCase							)


if __name__ == "__main__":
				print(F'''{solution() = }''')