




import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_layoutlm import LayoutLMTokenizer


_lowerCamelCase    				=		logging.get_logger(__name__)

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

_lowerCamelCase    				=		{
    'vocab_file': {
        'microsoft/layoutlm-base-uncased': (
            'https://huggingface.co/microsoft/layoutlm-base-uncased/resolve/main/vocab.txt'
        ),
        'microsoft/layoutlm-large-uncased': (
            'https://huggingface.co/microsoft/layoutlm-large-uncased/resolve/main/vocab.txt'
        ),
    },
    'tokenizer_file': {
        'microsoft/layoutlm-base-uncased': (
            'https://huggingface.co/microsoft/layoutlm-base-uncased/resolve/main/tokenizer.json'
        ),
        'microsoft/layoutlm-large-uncased': (
            'https://huggingface.co/microsoft/layoutlm-large-uncased/resolve/main/tokenizer.json'
        ),
    },
}

_lowerCamelCase    				=		{
    'microsoft/layoutlm-base-uncased': 5_12,
    'microsoft/layoutlm-large-uncased': 5_12,
}

_lowerCamelCase    				=		{
    'microsoft/layoutlm-base-uncased': {'do_lower_case': True},
    'microsoft/layoutlm-large-uncased': {'do_lower_case': True},
}



class     a  (     _A    ):

     '''simple docstring'''





     lowerCAmelCase       : Optional[int]     	=						VOCAB_FILES_NAMES
     lowerCAmelCase       : Tuple     	=						PRETRAINED_VOCAB_FILES_MAP
     lowerCAmelCase       : List[Any]     	=						PRETRAINED_INIT_CONFIGURATION
     lowerCAmelCase       : Dict     	=						PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
     lowerCAmelCase       : Dict     	=						LayoutLMTokenizer
     def __init__(			self     :    Union[str, Any]      ,					__snake_case     :    List[str]=None      ,					__snake_case     :    List[Any]=None      ,					__snake_case     :    List[str]=True      ,					__snake_case     :    int="[UNK]"      ,					__snake_case     :    List[Any]="[SEP]"      ,					__snake_case     :    Tuple="[PAD]"      ,					__snake_case     :    str="[CLS]"      ,					__snake_case     :    Union[str, Any]="[MASK]"      ,					__snake_case     :    Dict=True      ,					__snake_case     :    int=None      ,					**__snake_case     :    Tuple      ,					):
         super().__init__(
             __snake_case      ,					tokenizer_file=__snake_case      ,					do_lower_case=__snake_case      ,					unk_token=__snake_case      ,					sep_token=__snake_case      ,					pad_token=__snake_case      ,					cls_token=__snake_case      ,					mask_token=__snake_case      ,					tokenize_chinese_chars=__snake_case      ,					strip_accents=__snake_case      ,					**__snake_case      ,					)

         UpperCAmelCase_											=  json.loads(self.backend_tokenizer.normalizer.__getstate__()       )
         if (
             normalizer_state.get('''lowercase'''      ,					__snake_case       ) != do_lower_case
             or normalizer_state.get('''strip_accents'''      ,					__snake_case       ) != strip_accents
             or normalizer_state.get('''handle_chinese_chars'''      ,					__snake_case       ) != tokenize_chinese_chars
         ):
             UpperCAmelCase_											=  getattr(__snake_case      ,					normalizer_state.pop('''type'''       )       )
             UpperCAmelCase_											=  do_lower_case
             UpperCAmelCase_											=  strip_accents
             UpperCAmelCase_											=  tokenize_chinese_chars
             UpperCAmelCase_											=  normalizer_class(**__snake_case       )

         UpperCAmelCase_											=  do_lower_case
     def 						lowerCamelCase_     (			self     :    int      ,					__snake_case     :    Optional[int]      ,					__snake_case     :    str=None       ):
         UpperCAmelCase_											=  [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     :    Optional[Any]      ,					__snake_case     :    List[int]      ,					__snake_case     :    Optional[List[int]] = None       ):
         UpperCAmelCase_											=  [self.sep_token_id]
         UpperCAmelCase_											=  [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     :    Any      ,					__snake_case     :    str      ,					__snake_case     :    Optional[str] = None       ):
         UpperCAmelCase_											=  self._tokenizer.model.save(__snake_case      ,					name=__snake_case       )
         return tuple(__snake_case       )











import decimal




def       SCREAMING_SNAKE_CASE			( )						->							int:
    UpperCAmelCase_											=  0
    UpperCAmelCase_											=  decimal.Context(prec=105   )
    for i in range(2 ,  100   ):
        UpperCAmelCase_											=  decimal.Decimal(__UpperCamelCase   )
        UpperCAmelCase_											=  number.sqrt(__UpperCamelCase   )
        if len(str(__UpperCamelCase   )   ) > 1:
            answer += int(str(__UpperCamelCase   )[0]   )
            UpperCAmelCase_											=  str(__UpperCamelCase   )[2:101]
            answer += sum(int(__UpperCamelCase   ) for x in sqrt_number_str   )
    return answer


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 print(F"{solution() = }")





