
'''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_layoutlm import LayoutLMTokenizer


UpperCAmelCase            = logging.get_logger(__name__)

UpperCAmelCase            = {"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"}

UpperCAmelCase            = {
    "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"
        ),
    },
}

UpperCAmelCase            = {
    "microsoft/layoutlm-base-uncased": 512,
    "microsoft/layoutlm-large-uncased": 512,
}

UpperCAmelCase            = {
    "microsoft/layoutlm-base-uncased": {"do_lower_case": True},
    "microsoft/layoutlm-large-uncased": {"do_lower_case": True},
}

class     a (					__magic_name__     ):
				_snake_case		     =			VOCAB_FILES_NAMES
				_snake_case		     =			PRETRAINED_VOCAB_FILES_MAP
				_snake_case		     =			PRETRAINED_INIT_CONFIGURATION
				_snake_case		     =			PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				_snake_case		     =			LayoutLMTokenizer




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

										snake_case							:  Optional[Any]			=     json.loads(self.backend_tokenizer.normalizer.__getstate__()   )
										if (
										    normalizer_state.get('''lowercase''',     SCREAMING_SNAKE_CASE_   ) != do_lower_case
										    or normalizer_state.get('''strip_accents''',     SCREAMING_SNAKE_CASE_   ) != strip_accents
										    or normalizer_state.get('''handle_chinese_chars''',     SCREAMING_SNAKE_CASE_   ) != tokenize_chinese_chars
										):
																snake_case							:  List[str]			=     getattr(SCREAMING_SNAKE_CASE_,     normalizer_state.pop('''type'''   )   )
																snake_case							:  Dict			=     do_lower_case
																snake_case							:  List[str]			=     strip_accents
																snake_case							:  List[Any]			=     tokenize_chinese_chars
																snake_case							:  Optional[int]			=     normalizer_class(**SCREAMING_SNAKE_CASE_   )

										snake_case							:  List[str]			=     do_lower_case




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








def      a    (   _lowercase :  Dict			,    _lowercase :  List[str]							)  ->List[Any]:
		if len(str(_lowercase							)							) == 1 or len(str(_lowercase							)							) == 1:
				return a * b

		UpperCamelCase__								=						max(len(str(_lowercase							)							)			,    len(str(_lowercase							)							)							)
		UpperCamelCase__								=						ma // 2

		UpperCamelCase__	,      UpperCamelCase__								=						divmod(_lowercase			,    1_0**ma							)
		UpperCamelCase__	,      UpperCamelCase__								=						divmod(_lowercase			,    1_0**ma							)

		UpperCamelCase__								=						karatsuba(_lowercase			,    _lowercase							)
		UpperCamelCase__								=						karatsuba((aa + aa)			,    (ba + ba)							)
		UpperCamelCase__								=						karatsuba(_lowercase			,    _lowercase							)

		return (z * 1_0 ** (2 * ma)) + ((y - z - x) * 1_0 ** (ma)) + (x)

def      a    (   )  ->List[Any]:
		print(karatsuba(1_5_4_6_3			,    2_3_4_8_9							)							)


if __name__ == "__main__":
				main()





