


'''simple docstring'''
import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ....tokenization_utils_fast import PreTrainedTokenizerFast
from ....utils import logging
from .tokenization_retribert import RetriBertTokenizer


UpperCamelCase__    					=      logging.get_logger(__name__)

UpperCamelCase__    					=      {'''vocab_file''': '''vocab.txt''', '''tokenizer_file''': '''tokenizer.json'''}

UpperCamelCase__    					=      {
    '''vocab_file''': {
        '''yjernite/retribert-base-uncased''': (
            '''https://huggingface.co/yjernite/retribert-base-uncased/resolve/main/vocab.txt'''
        ),
    },
    '''tokenizer_file''': {
        '''yjernite/retribert-base-uncased''': (
            '''https://huggingface.co/yjernite/retribert-base-uncased/resolve/main/tokenizer.json'''
        ),
    },
}

UpperCamelCase__    					=      {
    '''yjernite/retribert-base-uncased''': 5_1_2,
}


UpperCamelCase__    					=      {
    '''yjernite/retribert-base-uncased''': {'''do_lower_case''': True},
}




class 			lowerCamelCase_   (	_UpperCAmelCase      ):
      lowerCAmelCase__		     =     VOCAB_FILES_NAMES
      lowerCAmelCase__		     =     PRETRAINED_VOCAB_FILES_MAP
      lowerCAmelCase__		     =     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
      lowerCAmelCase__		     =     PRETRAINED_INIT_CONFIGURATION
      lowerCAmelCase__		     =     RetriBertTokenizer
      lowerCAmelCase__		     =     ["input_ids", "attention_mask"]






      def __init__(					self				:    str						,						_A				:    Union[str, Any]=None						,						_A				:    str=None						,						_A				:    List[str]=True						,						_A				:    List[Any]="[UNK]"						,						_A				:    Any="[SEP]"						,						_A				:    List[str]="[PAD]"						,						_A				:    Optional[int]="[CLS]"						,						_A				:    Union[str, Any]="[MASK]"						,						_A				:    Any=True						,						_A				:    Union[str, Any]=None						,						**_A				:    List[Any]						,						):


          '''simple docstring'''


          super().__init__(
              _UpperCAmelCase						,						tokenizer_file=_UpperCAmelCase						,						do_lower_case=_UpperCAmelCase						,						unk_token=_UpperCAmelCase						,						sep_token=_UpperCAmelCase						,						pad_token=_UpperCAmelCase						,						cls_token=_UpperCAmelCase						,						mask_token=_UpperCAmelCase						,						tokenize_chinese_chars=_UpperCAmelCase						,						strip_accents=_UpperCAmelCase						,						**_UpperCAmelCase						,						)

          UpperCAmelCase__			:		Optional[Any]													=				json.loads(self.backend_tokenizer.normalizer.__getstate__() )
          if (
              normalizer_state.get('''lowercase'''						,						_UpperCAmelCase ) != do_lower_case
              or normalizer_state.get('''strip_accents'''						,						_UpperCAmelCase ) != strip_accents
              or normalizer_state.get('''handle_chinese_chars'''						,						_UpperCAmelCase ) != tokenize_chinese_chars
          ):
              UpperCAmelCase__			:		str													=				getattr(_UpperCAmelCase						,						normalizer_state.pop('''type''' ) )
              UpperCAmelCase__			:		Optional[Any]													=				do_lower_case
              UpperCAmelCase__			:		Tuple													=				strip_accents
              UpperCAmelCase__			:		str													=				tokenize_chinese_chars
              UpperCAmelCase__			:		Union[str, Any]													=				normalizer_class(**_UpperCAmelCase )

          UpperCAmelCase__			:		List[str]													=				do_lower_case






      def lowercase_							(					self				:    Union[str, Any]						,						_A				:    str						,						_A				:    Union[str, Any]=None ):


          '''simple docstring'''


          UpperCAmelCase__			:		Union[str, Any]													=				[self.cls_token_id] + token_ids_a + [self.sep_token_id]

          if token_ids_a:
              output += token_ids_a + [self.sep_token_id]

          return output






      def lowercase_							(					self				:    Tuple						,						_A				:    int						,						_A				:    str = None ):


          '''simple docstring'''


          UpperCAmelCase__			:		Optional[int]													=				[self.sep_token_id]
          UpperCAmelCase__			:		Union[str, Any]													=				[self.cls_token_id]
          if token_ids_a is None:
              return len(cls + token_ids_a + sep ) * [0]
          return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1]






      def lowercase_							(					self				:    Union[str, Any]						,						_A				:    Union[str, Any]						,						_A				:    Optional[Any] = None ):


          '''simple docstring'''


          UpperCAmelCase__			:		List[str]													=				self._tokenizer.model.save(_UpperCAmelCase						,						name=_UpperCAmelCase )
          return tuple(_UpperCAmelCase )

"""simple docstring"""






def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase=2_8_1_2_3 )  ->  Any:
   lowercase__:   Optional[Any]					=      [1] * (limit + 1)

   for i in range(2       ,    int(limit**0.5 ) + 1 ):
      sum_divs[i * i] += i
      for k in range(i + 1       ,    limit // i + 1 ):
         sum_divs[k * i] += k + i

   lowercase__:   Union[str, Any]					=      set()
   lowercase__:   Optional[Any]					=      0

   for n in range(1       ,    limit + 1 ):
      if sum_divs[n] > n:
         abundants.add(__UpperCAmelCase )

      if not any((n - a in abundants) for a in abundants ):
         res += n

   return res


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