





'''simple docstring'''




from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


__UpperCAmelCase         =   logging.get_logger(__name__)

__UpperCAmelCase         =   {
    """google/rembert""": """https://huggingface.co/google/rembert/resolve/main/config.json""",
    # See all RemBERT models at https://huggingface.co/models?filter=rembert
}




class       UpperCamelCase__			(			lowercase_	):




					"""simple docstring"""
					SCREAMING_SNAKE_CASE__						=					'''rembert'''


					def __init__(		self							:	Tuple     ,		lowerCamelCase_							:	Optional[Any]=25_03_00     ,		lowerCamelCase_							:	Dict=11_52     ,		lowerCamelCase_							:	Optional[Any]=32     ,		lowerCamelCase_							:	Union[str, Any]=18     ,		lowerCamelCase_							:	Union[str, Any]=2_56     ,		lowerCamelCase_							:	List[str]=16_64     ,		lowerCamelCase_							:	List[Any]=46_08     ,		lowerCamelCase_							:	Optional[int]="gelu"     ,		lowerCamelCase_							:	int=0.0     ,		lowerCamelCase_							:	List[str]=0.0     ,		lowerCamelCase_							:	str=0.1     ,		lowerCamelCase_							:	List[Any]=5_12     ,		lowerCamelCase_							:	List[str]=2     ,		lowerCamelCase_							:	int=0.02     ,		lowerCamelCase_							:	Union[str, Any]=1e-12     ,		lowerCamelCase_							:	Tuple=True     ,		lowerCamelCase_							:	Optional[int]=0     ,		lowerCamelCase_							:	Union[str, Any]=3_12     ,		lowerCamelCase_							:	List[str]=3_13     ,		**lowerCamelCase_							:	Union[str, Any]     ,		):

							'''simple docstring'''



							super().__init__(pad_token_id=lowerCamelCase_     ,		bos_token_id=lowerCamelCase_     ,		eos_token_id=lowerCamelCase_     ,		**lowerCamelCase_		)

							SCREAMING_SNAKE_CASE				:							str						=	vocab_size
							SCREAMING_SNAKE_CASE				:							List[str]						=	input_embedding_size
							SCREAMING_SNAKE_CASE				:							List[str]						=	output_embedding_size
							SCREAMING_SNAKE_CASE				:							List[str]						=	max_position_embeddings
							SCREAMING_SNAKE_CASE				:							str						=	hidden_size
							SCREAMING_SNAKE_CASE				:							List[str]						=	num_hidden_layers
							SCREAMING_SNAKE_CASE				:							List[Any]						=	num_attention_heads
							SCREAMING_SNAKE_CASE				:							Optional[int]						=	intermediate_size
							SCREAMING_SNAKE_CASE				:							Dict						=	hidden_act
							SCREAMING_SNAKE_CASE				:							str						=	hidden_dropout_prob
							SCREAMING_SNAKE_CASE				:							List[str]						=	attention_probs_dropout_prob
							SCREAMING_SNAKE_CASE				:							int						=	classifier_dropout_prob
							SCREAMING_SNAKE_CASE				:							str						=	initializer_range
							SCREAMING_SNAKE_CASE				:							int						=	type_vocab_size
							SCREAMING_SNAKE_CASE				:							Union[str, Any]						=	layer_norm_eps
							SCREAMING_SNAKE_CASE				:							Optional[Any]						=	use_cache
							SCREAMING_SNAKE_CASE				:							Optional[int]						=	False







class       UpperCamelCase__			(			lowercase_	):




					"""simple docstring"""


					@property
					def lowerCamelCase_	(		self							:	str		):

							'''simple docstring'''



							if self.task == "multiple-choice":
									SCREAMING_SNAKE_CASE				:							Dict						=	{0: """batch""", 1: """choice""", 2: """sequence"""}
							else:
									SCREAMING_SNAKE_CASE				:							Optional[int]						=	{0: """batch""", 1: """sequence"""}
							return OrderedDict(
							    [
							        ("""input_ids""", dynamic_axis),
							        ("""attention_mask""", dynamic_axis),
							        ("""token_type_ids""", dynamic_axis),
							    ]		)



					@property
					def lowerCamelCase_	(		self							:	str		):

							'''simple docstring'''



							return 1e-4










'''simple docstring'''




from __future__ import annotations

from collections import Counter



def 						__A						(       lowerCamelCase_					):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE				:							int						=	[True] * n
		SCREAMING_SNAKE_CASE				:							Optional[Any]						=	False
		SCREAMING_SNAKE_CASE				:							Optional[Any]						=	False
		SCREAMING_SNAKE_CASE				:							Optional[int]						=	True

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

		SCREAMING_SNAKE_CASE				:							Dict						=	[2]

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

		return primes



def 						__A						(       lowerCamelCase_					):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE				:							List[str]						=	str(lowerCamelCase_					)
		SCREAMING_SNAKE_CASE				:							List[str]						=	[]
		SCREAMING_SNAKE_CASE				:							Optional[int]						=	["""0""", """1""", """2""", """3""", """4""", """5""", """6""", """7""", """8""", """9"""]

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

		return replacements



def 						__A						(       lowerCamelCase_ = 8					):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE				:							Tuple						=	set()

		# Filter primes with less than 3 replaceable digits
		SCREAMING_SNAKE_CASE				:							Union[str, Any]						=	{
		    x for x in set(prime_sieve(1_00_00_00					)					) if len(str(lowerCamelCase_					)					) - len(set(str(lowerCamelCase_					)					)					) >= 3
		}

		for prime in primes:
				if prime in numbers_checked:
						continue

				SCREAMING_SNAKE_CASE				:							int						=	digit_replacements(lowerCamelCase_					)

				for family in replacements:
						numbers_checked.update(lowerCamelCase_					)
						SCREAMING_SNAKE_CASE				:							Dict						=	primes.intersection(lowerCamelCase_					)

						if len(lowerCamelCase_					) != family_length:
								continue

						return min(lowerCamelCase_					)

		return -1


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



