
'''simple docstring'''
from __future__ import annotations

from collections import Counter







def 						A_(			A		:						int):
							UpperCamelCase					       =			[True] * n
							UpperCamelCase					       =			False
							UpperCamelCase					       =			False
							UpperCamelCase					       =			True

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

							UpperCamelCase					       =			[2]

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

							return primes







def 						A_(			A		:						int):
							UpperCamelCase					       =			str(A)
							UpperCamelCase					       =			[]
							UpperCamelCase					       =			['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']

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

							return replacements







def 						A_(			A		:						int = 8):
							UpperCamelCase					       =			set()

							# Filter primes with less than 3 replaceable digits
							UpperCamelCase					       =			{
							    x for x in set(prime_sieve(100_0000)) if len(str(A)) - len(set(str(A))) >= 3
							}

							for prime in primes:
														if prime in numbers_checked:
																					continue

														UpperCamelCase					       =			digit_replacements(A)

														for family in replacements:
																					numbers_checked.update(A)
																					UpperCamelCase					       =			primes.intersection(A)

																					if len(A) != family_length:
																												continue

																					return min(A)

							return -1


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










import numpy as np  # noqa: E402

from ...configuration_utils import ConfigMixin, register_to_config
from ...schedulers.scheduling_utils import SchedulerMixin


try:
	import librosa  # noqa: E402

	_lowerCamelCase					:     Union[str, Any]					  =  True
	_lowerCamelCase					:     Optional[Any]					  =  ""
except Exception as e:
	_lowerCamelCase					:     int					  =  False
	_lowerCamelCase					:     List[str]					  =  (
	    F'''Cannot import librosa because {e}. Make sure to correctly install librosa to be able to install it.'''
	)


from PIL import Image  # noqa: E402
class 				__snake_case     (_a  ,		_a						):
				lowerCAmelCase__			=   "mel_config.json"



				@register_to_config
				def __init__(					self					:						Dict						,		_UpperCAmelCase					:						int = 256						,		_UpperCAmelCase					:						int = 256						,		_UpperCAmelCase					:						int = 2_2050						,		_UpperCAmelCase					:						int = 2048						,		_UpperCAmelCase					:						int = 512						,		_UpperCAmelCase					:						int = 80						,		_UpperCAmelCase					:						int = 32						,		)     ->			List[Any]:





								'''simple docstring'''




								_lowerCAmelCase			:			List[str]        =					hop_length
								_lowerCAmelCase			:			Optional[Any]        =					sample_rate
								_lowerCAmelCase			:			Optional[Any]        =					n_fft
								_lowerCAmelCase			:			Dict        =					top_db
								_lowerCAmelCase			:			List[Any]        =					n_iter
								self.set_resolution(_UpperCAmelCase						,		_UpperCAmelCase					)
								_lowerCAmelCase			:			Optional[int]        =					None

								if not _librosa_can_be_imported:
												raise ValueError(_import_error					)



				def 					SCREAMING_SNAKE_CASE				(					self					:						Optional[int]						,		_UpperCAmelCase					:						int						,		_UpperCAmelCase					:						int					)     ->			List[Any]:





								'''simple docstring'''




								_lowerCAmelCase			:			Dict        =					x_res
								_lowerCAmelCase			:			Union[str, Any]        =					y_res
								_lowerCAmelCase			:			Any        =					self.y_res
								_lowerCAmelCase			:			Optional[Any]        =					self.x_res * self.hop_length - 1



				def 					SCREAMING_SNAKE_CASE				(					self					:						Dict						,		_UpperCAmelCase					:						str = None						,		_UpperCAmelCase					:						np.ndarray = None					)     ->			List[str]:





								'''simple docstring'''




								if audio_file is not None:
												_lowerCAmelCase    ,			_lowerCAmelCase			:			Dict        =					librosa.load(_UpperCAmelCase						,		mono=_UpperCAmelCase						,		sr=self.sr					)
								else:
												_lowerCAmelCase			:			Any        =					raw_audio

								# Pad with silence if necessary.
								if len(self.audio					) < self.x_res * self.hop_length:
												_lowerCAmelCase			:			Optional[Any]        =					np.concatenate([self.audio, np.zeros((self.x_res * self.hop_length - len(self.audio					),)					)]					)



				def 					SCREAMING_SNAKE_CASE				(					self					:						Any					)     ->			int:





								'''simple docstring'''




								return len(self.audio					) // self.slice_size



				def 					SCREAMING_SNAKE_CASE				(					self					:						List[str]						,		_UpperCAmelCase					:						int = 0					)     ->			np.ndarray:





								'''simple docstring'''




								return self.audio[self.slice_size * slice : self.slice_size * (slice + 1)]



				def 					SCREAMING_SNAKE_CASE				(					self					:						List[Any]					)     ->			int:





								'''simple docstring'''




								return self.sr



				def 					SCREAMING_SNAKE_CASE				(					self					:						Dict						,		_UpperCAmelCase					:						int					)     ->			Image.Image:





								'''simple docstring'''




								_lowerCAmelCase			:			Union[str, Any]        =					librosa.feature.melspectrogram(
								    y=self.get_audio_slice(_UpperCAmelCase					)						,		sr=self.sr						,		n_fft=self.n_fft						,		hop_length=self.hop_length						,		n_mels=self.n_mels					)
								_lowerCAmelCase			:			List[Any]        =					librosa.power_to_db(_UpperCAmelCase						,		ref=np.max						,		top_db=self.top_db					)
								_lowerCAmelCase			:			List[Any]        =					(((log_S + self.top_db) * 255 / self.top_db).clip(0						,		255					) + 0.5).astype(np.uinta					)
								_lowerCAmelCase			:			Optional[Any]        =					Image.fromarray(_UpperCAmelCase					)
								return image



				def 					SCREAMING_SNAKE_CASE				(					self					:						Optional[int]						,		_UpperCAmelCase					:						Image.Image					)     ->			np.ndarray:





								'''simple docstring'''




								_lowerCAmelCase			:			Optional[int]        =					np.frombuffer(image.tobytes()						,		dtype="""uint8"""					).reshape((image.height, image.width)					)
								_lowerCAmelCase			:			Optional[int]        =					bytedata.astype("""float"""					) * self.top_db / 255 - self.top_db
								_lowerCAmelCase			:			List[Any]        =					librosa.db_to_power(_UpperCAmelCase					)
								_lowerCAmelCase			:			Optional[int]        =					librosa.feature.inverse.mel_to_audio(
								    _UpperCAmelCase						,		sr=self.sr						,		n_fft=self.n_fft						,		hop_length=self.hop_length						,		n_iter=self.n_iter					)
								return audio

