





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__          ={
    'squeezebert/squeezebert-uncased': (
        'https://huggingface.co/squeezebert/squeezebert-uncased/resolve/main/config.json'
    ),
    'squeezebert/squeezebert-mnli': 'https://huggingface.co/squeezebert/squeezebert-mnli/resolve/main/config.json',
    'squeezebert/squeezebert-mnli-headless': (
        'https://huggingface.co/squeezebert/squeezebert-mnli-headless/resolve/main/config.json'
    ),
}





class 	lowerCAmelCase__(       __lowercase			):






       '''simple docstring'''


       __snake_case       	=			SQUEEZEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP
       __snake_case       	=			'squeezebert'




       def __init__(					self			,  __lowerCamelCase=3_0_5_2_2			,  __lowerCamelCase=7_6_8			,  __lowerCamelCase=1_2			,  __lowerCamelCase=1_2			,  __lowerCamelCase=3_0_7_2			,  __lowerCamelCase="gelu"			,  __lowerCamelCase=0.1			,  __lowerCamelCase=0.1			,  __lowerCamelCase=5_1_2			,  __lowerCamelCase=2			,  __lowerCamelCase=0.02			,  __lowerCamelCase=1E-12			,  __lowerCamelCase=0			,  __lowerCamelCase=7_6_8			,  __lowerCamelCase=4			,  __lowerCamelCase=4			,  __lowerCamelCase=4			,  __lowerCamelCase=1			,  __lowerCamelCase=4			,  __lowerCamelCase=4			,  **__lowerCamelCase			,  )	->   Union[str, Any]:
            super().__init__(pad_token_id=__lowerCamelCase			,  **__lowerCamelCase							)

            _SCREAMING_SNAKE_CASE				:		Dict  			=							vocab_size
            _SCREAMING_SNAKE_CASE				:		Dict  			=							hidden_size
            _SCREAMING_SNAKE_CASE				:		Dict  			=							num_hidden_layers
            _SCREAMING_SNAKE_CASE				:		List[str]  			=							num_attention_heads
            _SCREAMING_SNAKE_CASE				:		Optional[Any]  			=							hidden_act
            _SCREAMING_SNAKE_CASE				:		str  			=							intermediate_size
            _SCREAMING_SNAKE_CASE				:		Optional[Any]  			=							hidden_dropout_prob
            _SCREAMING_SNAKE_CASE				:		Tuple  			=							attention_probs_dropout_prob
            _SCREAMING_SNAKE_CASE				:		Any  			=							max_position_embeddings
            _SCREAMING_SNAKE_CASE				:		Union[str, Any]  			=							type_vocab_size
            _SCREAMING_SNAKE_CASE				:		int  			=							initializer_range
            _SCREAMING_SNAKE_CASE				:		Optional[int]  			=							layer_norm_eps
            _SCREAMING_SNAKE_CASE				:		str  			=							embedding_size
            _SCREAMING_SNAKE_CASE				:		Optional[Any]  			=							q_groups
            _SCREAMING_SNAKE_CASE				:		str  			=							k_groups
            _SCREAMING_SNAKE_CASE				:		Dict  			=							v_groups
            _SCREAMING_SNAKE_CASE				:		Optional[Any]  			=							post_attention_groups
            _SCREAMING_SNAKE_CASE				:		Union[str, Any]  			=							intermediate_groups
            _SCREAMING_SNAKE_CASE				:		List[Any]  			=							output_groups





class 	lowerCAmelCase__(       __lowercase			):






       '''simple docstring'''


       @property
       def 			UpperCamelCase_	(					self							)	->   Mapping[str, Mapping[int, str]]:
            if self.task == "multiple-choice":
                 _SCREAMING_SNAKE_CASE				:		List[str]  			=							{0: "batch", 1: "choice", 2: "sequence"}
            else:
                 _SCREAMING_SNAKE_CASE				:		Tuple  			=							{0: "batch", 1: "sequence"}
            return OrderedDict(
                [
                    ("input_ids", dynamic_axis),
                    ("attention_mask", dynamic_axis),
                    ("token_type_ids", dynamic_axis),
                ]							)






import sys

sys.set_int_max_str_digits(0)  # type: ignore






def 			lowerCamelCase__	(__lowerCamelCase		):
     _SCREAMING_SNAKE_CASE				:		int  			=							[0] * 11
     _SCREAMING_SNAKE_CASE				:		Optional[Any]  			=							[0] * 11

     # mark last 9 numbers
     for _ in range(9		):
          _SCREAMING_SNAKE_CASE				:		Optional[Any]  			=							1
          _SCREAMING_SNAKE_CASE				:		str  			=							number // 10
     # flag
     _SCREAMING_SNAKE_CASE				:		int  			=							True

     # check last 9 numbers for pandigitality

     for x in range(9		):
          if not check_last[x + 1]:
               _SCREAMING_SNAKE_CASE				:		Any  			=							False
     if not f:
          return f

     # mark first 9 numbers
     _SCREAMING_SNAKE_CASE				:		str  			=							int(str(__lowerCamelCase		)[:9]		)

     for _ in range(9		):
          _SCREAMING_SNAKE_CASE				:		str  			=							1
          _SCREAMING_SNAKE_CASE				:		List[Any]  			=							number // 10

     # check first 9 numbers for pandigitality

     for x in range(9		):
          if not check_front[x + 1]:
               _SCREAMING_SNAKE_CASE				:		Any  			=							False
     return f






def 			lowerCamelCase__	(__lowerCamelCase		):
     _SCREAMING_SNAKE_CASE				:		List[str]  			=							[0] * 11

     # mark last 9 numbers
     for _ in range(9		):
          _SCREAMING_SNAKE_CASE				:		Dict  			=							1
          _SCREAMING_SNAKE_CASE				:		List[str]  			=							number // 10
     # flag
     _SCREAMING_SNAKE_CASE				:		List[Any]  			=							True

     # check last 9 numbers for pandigitality

     for x in range(9		):
          if not check_last[x + 1]:
               _SCREAMING_SNAKE_CASE				:		str  			=							False
     return f






def 			lowerCamelCase__	():
     _SCREAMING_SNAKE_CASE				:		Dict  			=							1
     _SCREAMING_SNAKE_CASE				:		Union[str, Any]  			=							1
     _SCREAMING_SNAKE_CASE				:		List[str]  			=							2
     # temporary Fibonacci numbers

     _SCREAMING_SNAKE_CASE				:		Any  			=							1
     _SCREAMING_SNAKE_CASE				:		List[str]  			=							1
     _SCREAMING_SNAKE_CASE				:		str  			=							2
     # temporary Fibonacci numbers mod 1e9

     # mod m=1e9, done for fast optimisation
     _SCREAMING_SNAKE_CASE				:		Optional[Any]  			=							[0] * 1000000
     _SCREAMING_SNAKE_CASE				:		Optional[int]  			=							1000000000

     for x in range(1000000		):
          _SCREAMING_SNAKE_CASE				:		Union[str, Any]  			=							(aa + ba) % m
          _SCREAMING_SNAKE_CASE				:		int  			=							ba % m
          _SCREAMING_SNAKE_CASE				:		List[str]  			=							ca % m
          if checka(__lowerCamelCase		):
               _SCREAMING_SNAKE_CASE				:		List[Any]  			=							1

     for x in range(1000000		):
          _SCREAMING_SNAKE_CASE				:		Any  			=							a + b
          _SCREAMING_SNAKE_CASE				:		Dict  			=							b
          _SCREAMING_SNAKE_CASE				:		int  			=							c
          # perform check only if in tocheck
          if tocheck[x + 3] and check(__lowerCamelCase		):
               return x + 3  # first 2 already done
     return -1


if __name__ == "__main__":
       print(f"{solution() = }")