
'''simple docstring'''
import sys

sys.set_int_max_str_digits(0)  # type: ignore






def       __SCREAMING_SNAKE_CASE   (						_SCREAMING_SNAKE_CASE   ):
							_snake_case     =						[0] * 11
							_snake_case     =						[0] * 11

							# mark last 9 numbers
							for _ in range(9   ):
														_snake_case     =						1
														_snake_case     =						number // 10
							# flag
							_snake_case     =						True

							# check last 9 numbers for pandigitality

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

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

							for _ in range(9   ):
														_snake_case     =						1
														_snake_case     =						number // 10

							# check first 9 numbers for pandigitality

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






def       __SCREAMING_SNAKE_CASE   (						_SCREAMING_SNAKE_CASE   ):
							_snake_case     =						[0] * 11

							# mark last 9 numbers
							for _ in range(9   ):
														_snake_case     =						1
														_snake_case     =						number // 10
							# flag
							_snake_case     =						True

							# check last 9 numbers for pandigitality

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






def       __SCREAMING_SNAKE_CASE   (						):
							_snake_case     =						1
							_snake_case     =						1
							_snake_case     =						2
							# temporary Fibonacci numbers

							_snake_case     =						1
							_snake_case     =						1
							_snake_case     =						2
							# temporary Fibonacci numbers mod 1e9

							# mod m=1e9, done for fast optimisation
							_snake_case     =						[0] * 100_0000
							_snake_case     =						10_0000_0000

							for x in range(100_0000   ):
														_snake_case     =						(aa + ba) % m
														_snake_case     =						ba % m
														_snake_case     =						ca % m
														if checka(_SCREAMING_SNAKE_CASE   ):
																					_snake_case     =						1

							for x in range(100_0000   ):
														_snake_case     =						a + b
														_snake_case     =						b
														_snake_case     =						c
														# perform check only if in tocheck
														if tocheck[x + 3] and check(_SCREAMING_SNAKE_CASE   ):
																					return x + 3  # first 2 already done
							return -1


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

'''simple docstring'''
import os
from shutil import copyfile
from typing import Optional, Tuple

from ...file_utils import is_sentencepiece_available
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging


if is_sentencepiece_available():
				from .tokenization_deberta_va import DebertaVaTokenizer
else:
				__lowerCAmelCase  							= None

__lowerCAmelCase  							= logging.get_logger(__name__)

__lowerCAmelCase  							= {'vocab_file': 'spm.model', 'tokenizer_file': 'tokenizer.json'}

__lowerCAmelCase  							= {
    'vocab_file': {
        'microsoft/deberta-v2-xlarge': 'https://huggingface.co/microsoft/deberta-v2-xlarge/resolve/main/spm.model',
        'microsoft/deberta-v2-xxlarge': 'https://huggingface.co/microsoft/deberta-v2-xxlarge/resolve/main/spm.model',
        'microsoft/deberta-v2-xlarge-mnli': (
            'https://huggingface.co/microsoft/deberta-v2-xlarge-mnli/resolve/main/spm.model'
        ),
        'microsoft/deberta-v2-xxlarge-mnli': (
            'https://huggingface.co/microsoft/deberta-v2-xxlarge-mnli/resolve/main/spm.model'
        ),
    }
}

__lowerCAmelCase  							= {
    'microsoft/deberta-v2-xlarge': 512,
    'microsoft/deberta-v2-xxlarge': 512,
    'microsoft/deberta-v2-xlarge-mnli': 512,
    'microsoft/deberta-v2-xxlarge-mnli': 512,
}

__lowerCAmelCase  							= {
    'microsoft/deberta-v2-xlarge': {'do_lower_case': False},
    'microsoft/deberta-v2-xxlarge': {'do_lower_case': False},
    'microsoft/deberta-v2-xlarge-mnli': {'do_lower_case': False},
    'microsoft/deberta-v2-xxlarge-mnli': {'do_lower_case': False},
}


class     _lowerCAmelCase					(					__snake_case   ):







							'''simple docstring'''

							lowerCAmelCase_      		=		VOCAB_FILES_NAMES
							lowerCAmelCase_      		=		PRETRAINED_VOCAB_FILES_MAP
							lowerCAmelCase_      		=		PRETRAINED_INIT_CONFIGURATION
							lowerCAmelCase_      		=		PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
							lowerCAmelCase_      		=		DebertaVaTokenizer

							def __init__(self						,						UpperCAmelCase=None						,						UpperCAmelCase=None						,						UpperCAmelCase=False						,						UpperCAmelCase=False						,						UpperCAmelCase="[CLS]"						,						UpperCAmelCase="[SEP]"						,						UpperCAmelCase="[UNK]"						,						UpperCAmelCase="[SEP]"						,						UpperCAmelCase="[PAD]"						,						UpperCAmelCase="[CLS]"						,						UpperCAmelCase="[MASK]"						,						**UpperCAmelCase						,						)  ->     None:
														super().__init__(
														    UpperCAmelCase						,						tokenizer_file=UpperCAmelCase						,						do_lower_case=UpperCAmelCase						,						bos_token=UpperCAmelCase						,						eos_token=UpperCAmelCase						,						unk_token=UpperCAmelCase						,						sep_token=UpperCAmelCase						,						pad_token=UpperCAmelCase						,						cls_token=UpperCAmelCase						,						mask_token=UpperCAmelCase						,						split_by_punct=UpperCAmelCase						,						**UpperCAmelCase						,						)

														_snake_case     =						do_lower_case
														_snake_case     =						split_by_punct
														_snake_case     =						vocab_file
														_snake_case     =						False if not self.vocab_file else True

							def  lowercase							(self						,						UpperCAmelCase						,						UpperCAmelCase=None						)  ->     List[Any]:

														if token_ids_a is None:
																					return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
														_snake_case     =						[self.cls_token_id]
														_snake_case     =						[self.sep_token_id]
														return cls + token_ids_a + sep + token_ids_a + sep

							def  lowercase							(self						,						UpperCAmelCase						,						UpperCAmelCase=None						,						UpperCAmelCase=False						)  ->     Union[str, Any]:

														if already_has_special_tokens:
																					return super().get_special_tokens_mask(
																					    token_ids_a=UpperCAmelCase						,						token_ids_a=UpperCAmelCase						,						already_has_special_tokens=UpperCAmelCase						)

														if token_ids_a is not None:
																					return [1] + ([0] * len(UpperCAmelCase						)) + [1] + ([0] * len(UpperCAmelCase						)) + [1]
														return [1] + ([0] * len(UpperCAmelCase						)) + [1]

							def  lowercase							(self						,						UpperCAmelCase						,						UpperCAmelCase=None						)  ->     str:
														_snake_case     =						[self.sep_token_id]
														_snake_case     =						[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						,						UpperCAmelCase						,						UpperCAmelCase = None						)  ->     Tuple[str]:
														if not self.can_save_slow_tokenizer:
																					raise ValueError(
																					    """Your fast tokenizer does not have the necessary information to save the vocabulary for a slow """
																					    """tokenizer."""						)

														if not os.path.isdir(UpperCAmelCase						):
																					logger.error(f"""Vocabulary path ({save_directory}) should be a directory"""						)
																					return
														_snake_case     =						os.path.join(
														    UpperCAmelCase						,						(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]						)

														if os.path.abspath(self.vocab_file						) != os.path.abspath(UpperCAmelCase						):
																					copyfile(self.vocab_file						,						UpperCAmelCase						)

														return (out_vocab_file,)