
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 __future__ import annotations

import math





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase				):

    if 1 < number < 4:
        # 2 and 3 are primes
        return True
    elif number < 2 or number % 2 == 0 or number % 3 == 0:
        # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
        return False

    # All primes number are in format of 6k +/- 1
    for i in range(5     ,		int(math.sqrt(__lowerCAmelCase				) + 1				)     ,		6				):
        if number % i == 0 or number % (i + 2) == 0:
            return False
    return True





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase				):
    snake_case__    =					str(__lowerCAmelCase				)
    snake_case__    =					[n]
    for i in range(1     ,		len(__lowerCAmelCase				)				):
        list_nums.append(int(str_num[i:]				)				)
        list_nums.append(int(str_num[:-i]				)				)
    return list_nums





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase				):
    if len(str(__lowerCAmelCase				)				) > 3:
        if not is_prime(int(str(__lowerCAmelCase				)[-3:]				)				) or not is_prime(int(str(__lowerCAmelCase				)[:3]				)				):
            return False
    return True





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase = 11				):
    snake_case__    =					[]
    snake_case__    =					13
    while len(__lowerCAmelCase				) != count:
        if validate(__lowerCAmelCase				):
            snake_case__    =					list_truncated_nums(__lowerCAmelCase				)
            if all(is_prime(__lowerCAmelCase				) for i in list_nums				):
                list_truncated_primes.append(__lowerCAmelCase				)
        num += 2
    return list_truncated_primes





def 						SCREAMING_SNAKE_CASE__     (   ):
    return sum(compute_truncated_primes(11				)				)


if __name__ == "__main__":
     print(F'''{sum(compute_truncated_primes(11)) = }''')



