

'''simple docstring'''

from collections import OrderedDict
from typing import Mapping

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


A_      =							logging.get_logger(__name__)

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





class 							_snake_case	(    _a  ):
   _A    :       Optional[Any]      				=   '''rembert'''
   def __init__(	self     : str       ,SCREAMING_SNAKE_CASE__     : List[str]=250_300       ,SCREAMING_SNAKE_CASE__     : str=1_152       ,SCREAMING_SNAKE_CASE__     : str=32       ,SCREAMING_SNAKE_CASE__     : Optional[int]=18       ,SCREAMING_SNAKE_CASE__     : Tuple=256       ,SCREAMING_SNAKE_CASE__     : Union[str, Any]=1_664       ,SCREAMING_SNAKE_CASE__     : str=4_608       ,SCREAMING_SNAKE_CASE__     : Union[str, Any]="gelu"       ,SCREAMING_SNAKE_CASE__     : int=0.0       ,SCREAMING_SNAKE_CASE__     : List[Any]=0.0       ,SCREAMING_SNAKE_CASE__     : Any=0.1       ,SCREAMING_SNAKE_CASE__     : Optional[int]=512       ,SCREAMING_SNAKE_CASE__     : Optional[Any]=2       ,SCREAMING_SNAKE_CASE__     : Tuple=0.02       ,SCREAMING_SNAKE_CASE__     : List[str]=1e-12       ,SCREAMING_SNAKE_CASE__     : int=True       ,SCREAMING_SNAKE_CASE__     : str=0       ,SCREAMING_SNAKE_CASE__     : List[Any]=312       ,SCREAMING_SNAKE_CASE__     : List[str]=313       ,**SCREAMING_SNAKE_CASE__     : str       ,):
     super().__init__(pad_token_id=SCREAMING_SNAKE_CASE__       ,bos_token_id=SCREAMING_SNAKE_CASE__       ,eos_token_id=SCREAMING_SNAKE_CASE__       ,**SCREAMING_SNAKE_CASE__							)

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





class 							_snake_case	(    _a  ):
   @property
   def       __UpperCamelCase  (	self     : Dict							):






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







   @property
   def       __UpperCamelCase  (	self     : Union[str, Any]							):
     return 1e-4









'''simple docstring'''

from __future__ import annotations

from collections import Counter





def 				A_					(	snake_case	):
  SCREAMING_SNAKE_CASE:int   =   [True] * n
  SCREAMING_SNAKE_CASE:List[str]   =   False
  SCREAMING_SNAKE_CASE:Tuple   =   False
  SCREAMING_SNAKE_CASE:int   =   True

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

  SCREAMING_SNAKE_CASE:Union[str, Any]   =   [2]

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

  return primes





def 				A_					(	snake_case	):
  SCREAMING_SNAKE_CASE:List[str]   =   str(snake_case	)
  SCREAMING_SNAKE_CASE:Union[str, Any]   =   []
  SCREAMING_SNAKE_CASE:List[str]   =   ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]

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

  return replacements





def 				A_					(	snake_case = 8	):
  SCREAMING_SNAKE_CASE:str   =   set()

  # Filter primes with less than 3 replaceable digits
  SCREAMING_SNAKE_CASE:Tuple   =   {
      x for x in set(prime_sieve(1000000	)	) if len(str(snake_case	)	) - len(set(str(snake_case	)	)	) >= 3
  }

  for prime in primes:
    if prime in numbers_checked:
      continue

    SCREAMING_SNAKE_CASE:List[Any]   =   digit_replacements(snake_case	)

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

      if len(snake_case	) != family_length:
        continue

      return min(snake_case	)

  return -1


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






