


"""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_bert import BertTokenizer


snake_case__						:   int			 = logging.get_logger(__name__)

snake_case__						:   List[str]			 = {'''vocab_file''': '''vocab.txt''', '''tokenizer_file''': '''tokenizer.json'''}

snake_case__						:   int			 = {
    '''vocab_file''': {
        '''bert-base-uncased''': '''https://huggingface.co/bert-base-uncased/resolve/main/vocab.txt''',
        '''bert-large-uncased''': '''https://huggingface.co/bert-large-uncased/resolve/main/vocab.txt''',
        '''bert-base-cased''': '''https://huggingface.co/bert-base-cased/resolve/main/vocab.txt''',
        '''bert-large-cased''': '''https://huggingface.co/bert-large-cased/resolve/main/vocab.txt''',
        '''bert-base-multilingual-uncased''': (
            '''https://huggingface.co/bert-base-multilingual-uncased/resolve/main/vocab.txt'''
        ),
        '''bert-base-multilingual-cased''': '''https://huggingface.co/bert-base-multilingual-cased/resolve/main/vocab.txt''',
        '''bert-base-chinese''': '''https://huggingface.co/bert-base-chinese/resolve/main/vocab.txt''',
        '''bert-base-german-cased''': '''https://huggingface.co/bert-base-german-cased/resolve/main/vocab.txt''',
        '''bert-large-uncased-whole-word-masking''': (
            '''https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/vocab.txt'''
        ),
        '''bert-large-cased-whole-word-masking''': (
            '''https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/vocab.txt'''
        ),
        '''bert-large-uncased-whole-word-masking-finetuned-squad''': (
            '''https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/vocab.txt'''
        ),
        '''bert-large-cased-whole-word-masking-finetuned-squad''': (
            '''https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/vocab.txt'''
        ),
        '''bert-base-cased-finetuned-mrpc''': (
            '''https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/vocab.txt'''
        ),
        '''bert-base-german-dbmdz-cased''': '''https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/vocab.txt''',
        '''bert-base-german-dbmdz-uncased''': (
            '''https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/vocab.txt'''
        ),
        '''TurkuNLP/bert-base-finnish-cased-v1''': (
            '''https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/vocab.txt'''
        ),
        '''TurkuNLP/bert-base-finnish-uncased-v1''': (
            '''https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/vocab.txt'''
        ),
        '''wietsedv/bert-base-dutch-cased''': (
            '''https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/vocab.txt'''
        ),
    },
    '''tokenizer_file''': {
        '''bert-base-uncased''': '''https://huggingface.co/bert-base-uncased/resolve/main/tokenizer.json''',
        '''bert-large-uncased''': '''https://huggingface.co/bert-large-uncased/resolve/main/tokenizer.json''',
        '''bert-base-cased''': '''https://huggingface.co/bert-base-cased/resolve/main/tokenizer.json''',
        '''bert-large-cased''': '''https://huggingface.co/bert-large-cased/resolve/main/tokenizer.json''',
        '''bert-base-multilingual-uncased''': (
            '''https://huggingface.co/bert-base-multilingual-uncased/resolve/main/tokenizer.json'''
        ),
        '''bert-base-multilingual-cased''': (
            '''https://huggingface.co/bert-base-multilingual-cased/resolve/main/tokenizer.json'''
        ),
        '''bert-base-chinese''': '''https://huggingface.co/bert-base-chinese/resolve/main/tokenizer.json''',
        '''bert-base-german-cased''': '''https://huggingface.co/bert-base-german-cased/resolve/main/tokenizer.json''',
        '''bert-large-uncased-whole-word-masking''': (
            '''https://huggingface.co/bert-large-uncased-whole-word-masking/resolve/main/tokenizer.json'''
        ),
        '''bert-large-cased-whole-word-masking''': (
            '''https://huggingface.co/bert-large-cased-whole-word-masking/resolve/main/tokenizer.json'''
        ),
        '''bert-large-uncased-whole-word-masking-finetuned-squad''': (
            '''https://huggingface.co/bert-large-uncased-whole-word-masking-finetuned-squad/resolve/main/tokenizer.json'''
        ),
        '''bert-large-cased-whole-word-masking-finetuned-squad''': (
            '''https://huggingface.co/bert-large-cased-whole-word-masking-finetuned-squad/resolve/main/tokenizer.json'''
        ),
        '''bert-base-cased-finetuned-mrpc''': (
            '''https://huggingface.co/bert-base-cased-finetuned-mrpc/resolve/main/tokenizer.json'''
        ),
        '''bert-base-german-dbmdz-cased''': (
            '''https://huggingface.co/bert-base-german-dbmdz-cased/resolve/main/tokenizer.json'''
        ),
        '''bert-base-german-dbmdz-uncased''': (
            '''https://huggingface.co/bert-base-german-dbmdz-uncased/resolve/main/tokenizer.json'''
        ),
        '''TurkuNLP/bert-base-finnish-cased-v1''': (
            '''https://huggingface.co/TurkuNLP/bert-base-finnish-cased-v1/resolve/main/tokenizer.json'''
        ),
        '''TurkuNLP/bert-base-finnish-uncased-v1''': (
            '''https://huggingface.co/TurkuNLP/bert-base-finnish-uncased-v1/resolve/main/tokenizer.json'''
        ),
        '''wietsedv/bert-base-dutch-cased''': (
            '''https://huggingface.co/wietsedv/bert-base-dutch-cased/resolve/main/tokenizer.json'''
        ),
    },
}

snake_case__						:   Any			 = {
    '''bert-base-uncased''': 512,
    '''bert-large-uncased''': 512,
    '''bert-base-cased''': 512,
    '''bert-large-cased''': 512,
    '''bert-base-multilingual-uncased''': 512,
    '''bert-base-multilingual-cased''': 512,
    '''bert-base-chinese''': 512,
    '''bert-base-german-cased''': 512,
    '''bert-large-uncased-whole-word-masking''': 512,
    '''bert-large-cased-whole-word-masking''': 512,
    '''bert-large-uncased-whole-word-masking-finetuned-squad''': 512,
    '''bert-large-cased-whole-word-masking-finetuned-squad''': 512,
    '''bert-base-cased-finetuned-mrpc''': 512,
    '''bert-base-german-dbmdz-cased''': 512,
    '''bert-base-german-dbmdz-uncased''': 512,
    '''TurkuNLP/bert-base-finnish-cased-v1''': 512,
    '''TurkuNLP/bert-base-finnish-uncased-v1''': 512,
    '''wietsedv/bert-base-dutch-cased''': 512,
}

snake_case__						:   Tuple			 = {
    '''bert-base-uncased''': {'''do_lower_case''': True},
    '''bert-large-uncased''': {'''do_lower_case''': True},
    '''bert-base-cased''': {'''do_lower_case''': False},
    '''bert-large-cased''': {'''do_lower_case''': False},
    '''bert-base-multilingual-uncased''': {'''do_lower_case''': True},
    '''bert-base-multilingual-cased''': {'''do_lower_case''': False},
    '''bert-base-chinese''': {'''do_lower_case''': False},
    '''bert-base-german-cased''': {'''do_lower_case''': False},
    '''bert-large-uncased-whole-word-masking''': {'''do_lower_case''': True},
    '''bert-large-cased-whole-word-masking''': {'''do_lower_case''': False},
    '''bert-large-uncased-whole-word-masking-finetuned-squad''': {'''do_lower_case''': True},
    '''bert-large-cased-whole-word-masking-finetuned-squad''': {'''do_lower_case''': False},
    '''bert-base-cased-finetuned-mrpc''': {'''do_lower_case''': False},
    '''bert-base-german-dbmdz-cased''': {'''do_lower_case''': False},
    '''bert-base-german-dbmdz-uncased''': {'''do_lower_case''': True},
    '''TurkuNLP/bert-base-finnish-cased-v1''': {'''do_lower_case''': False},
    '''TurkuNLP/bert-base-finnish-uncased-v1''': {'''do_lower_case''': True},
    '''wietsedv/bert-base-dutch-cased''': {'''do_lower_case''': False},
}



class 						snake_case_(				a__	):
     __UpperCamelCase     =    VOCAB_FILES_NAMES
     __UpperCamelCase     =    PRETRAINED_VOCAB_FILES_MAP
     __UpperCamelCase     =    PRETRAINED_INIT_CONFIGURATION
     __UpperCamelCase     =    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
     __UpperCamelCase     =    BertTokenizer






     def __init__(		self     :    Any    , UpperCamelCase_     :    List[str]=None    , UpperCamelCase_     :    Tuple=None    , UpperCamelCase_     :    Optional[int]=True    , UpperCamelCase_     :    Tuple="[UNK]"    , UpperCamelCase_     :    List[Any]="[SEP]"    , UpperCamelCase_     :    List[str]="[PAD]"    , UpperCamelCase_     :    List[Any]="[CLS]"    , UpperCamelCase_     :    str="[MASK]"    , UpperCamelCase_     :    List[Any]=True    , UpperCamelCase_     :    Tuple=None    , **UpperCamelCase_     :    Tuple    , ):
           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_    , )

           lowerCAmelCase    :		Tuple				=      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
           ):
                 lowerCAmelCase    :		Optional[Any]				=      getattr(UpperCamelCase_    , normalizer_state.pop('''type''' ) )
                 lowerCAmelCase    :		List[Any]				=      do_lower_case
                 lowerCAmelCase    :		Optional[Any]				=      strip_accents
                 lowerCAmelCase    :		Tuple				=      tokenize_chinese_chars
                 lowerCAmelCase    :		int				=      normalizer_class(**UpperCamelCase_ )

           lowerCAmelCase    :		Tuple				=      do_lower_case






     def    lowerCamelCase__   (		self     :    Dict    , UpperCamelCase_     :    Optional[int]    , UpperCamelCase_     :    int=None ):
           lowerCAmelCase    :		Dict				=      [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    lowerCamelCase__   (		self     :    str    , UpperCamelCase_     :    List[int]    , UpperCamelCase_     :    Optional[List[int]] = None ):
           lowerCAmelCase    :		int				=      [self.sep_token_id]
           lowerCAmelCase    :		List[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    lowerCamelCase__   (		self     :    str    , UpperCamelCase_     :    str    , UpperCamelCase_     :    Optional[str] = None ):
           lowerCAmelCase    :		str				=      self._tokenizer.model.save(UpperCamelCase_    , name=UpperCamelCase_ )
           return tuple(UpperCamelCase_ )



from math import isqrt






def  snake_case  (       snake_case__			:int)						->   bool:
       return all(number % divisor != 0 for divisor in range(2   ,	isqrt(snake_case__) + 1))






def  snake_case  (       snake_case__			:int = 10**6)						->   int:
       _A        =  0
       _A        =  1
       _A        =  7
       while prime_candidate < max_prime:
              primes_count += is_prime(snake_case__)

              cube_index += 1
              prime_candidate += 6 * cube_index

       return primes_count


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




