





from __future__ import annotations

from collections import Counter


def 				SCREAMING_SNAKE_CASE__    (     __a ):
	snake_case_		:      Optional[int]           =						[True] * n
	snake_case_		:      List[str]           =						False
	snake_case_		:      Dict           =						False
	snake_case_		:      List[str]           =						True

	for i in range(3 ,			int(n**0.5 + 1 ) ,			2 ):
		snake_case_		:      List[Any]           =						i * 2
		while index < n:
			snake_case_		:      List[str]           =						False
			snake_case_		:      int           =						index + i

	snake_case_		:      Optional[Any]           =						[2]

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

	return primes


def 				SCREAMING_SNAKE_CASE__    (     __a ):
	snake_case_		:      List[Any]           =						str(__a )
	snake_case_		:      Tuple           =						[]
	snake_case_		:      Tuple           =						['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']

	for duplicate in Counter(__a ) - Counter(set(__a ) ):
		snake_case_		:      int           =						[int(number_str.replace(__a ,			__a ) ) for digit in digits]
		replacements.append(__a )

	return replacements


def 				SCREAMING_SNAKE_CASE__    (     __a = 8 ):
	snake_case_		:      Optional[int]           =						set()

	# Filter primes with less than 3 replaceable digits
	snake_case_		:      Tuple           =						{
	    x for x in set(prime_sieve(1_00_00_00 ) ) if len(str(__a ) ) - len(set(str(__a ) ) ) >= 3
	}

	for prime in primes:
		if prime in numbers_checked:
			continue

		snake_case_		:      List[Any]           =						digit_replacements(__a )

		for family in replacements:
			numbers_checked.update(__a )
			snake_case_		:      Optional[Any]           =						primes.intersection(__a )

			if len(__a ) != family_length:
				continue

			return min(__a )

	return -1


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









"""simple docstring"""

from cva import destroyAllWindows, imread, imshow, waitKey






def _lowerCAmelCase						(	__lowerCamelCase:Tuple			,    __lowerCamelCase:int ):

						'''simple docstring'''






						__magic_name__   ,     __magic_name__      =  img.shape[0], img.shape[1]

						def to_grayscale(__lowerCamelCase:List[str]			,    __lowerCamelCase:Optional[Any]			,    __lowerCamelCase:int ):
												return 0.2_1_2_6 * red + 0.5_8_7 * green + 0.1_1_4 * blue

						def normalize(__lowerCamelCase:Union[str, Any] ):
												return min(__lowerCamelCase			,    2_5_5 )

						for i in range(__lowerCamelCase ):
												for j in range(__lowerCamelCase ):
																		__magic_name__      =  int(to_grayscale(*img[i][j] ) )
																		__magic_name__      =  [
																		    normalize(__lowerCamelCase ),
																		    normalize(greyscale + factor ),
																		    normalize(greyscale + 2 * factor ),
																		]

						return img


if __name__ == "__main__":
			# read original image
			lowercase           =							{
			    percentage: imread('''image_data/lena.jpg''', 1) for percentage in (10, 20, 30, 40)
			}

			for percentage, img in images.items():
						make_sepia(img, percentage)

			for percentage, img in images.items():
						imshow(f'''Original image with sepia (factor: {percentage})''', img)

			waitKey(0)
			destroyAllWindows()



