



import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from .tokenization_lxmert import LxmertTokenizer


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

__lowerCamelCase     :							str  							=				{
    '''vocab_file''': {
        '''unc-nlp/lxmert-base-uncased''': '''https://huggingface.co/unc-nlp/lxmert-base-uncased/resolve/main/vocab.txt''',
    },
    '''tokenizer_file''': {
        '''unc-nlp/lxmert-base-uncased''': (
            '''https://huggingface.co/unc-nlp/lxmert-base-uncased/resolve/main/tokenizer.json'''
        ),
    },
}

__lowerCamelCase     :							Any  							=				{
    '''unc-nlp/lxmert-base-uncased''': 512,
}

__lowerCamelCase     :							List[str]  							=				{
    '''unc-nlp/lxmert-base-uncased''': {'''do_lower_case''': True},
}





class  __magic_name__   (							A__						):
		lowercase      :       int          =VOCAB_FILES_NAMES
		lowercase      :       List[str]          =PRETRAINED_VOCAB_FILES_MAP
		lowercase      :       Union[str, Any]          =PRETRAINED_INIT_CONFIGURATION
		lowercase      :       Any          =PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
		lowercase      :       Any          =LxmertTokenizer






		def __init__(						self      :     int				,		UpperCamelCase__      :     Optional[Any]=None				,		UpperCamelCase__      :     Any=None				,		UpperCamelCase__      :     List[Any]=True				,		UpperCamelCase__      :     str="[UNK]"				,		UpperCamelCase__      :     Optional[Any]="[SEP]"				,		UpperCamelCase__      :     List[str]="[PAD]"				,		UpperCamelCase__      :     int="[CLS]"				,		UpperCamelCase__      :     List[Any]="[MASK]"				,		UpperCamelCase__      :     List[Any]=True				,		UpperCamelCase__      :     Optional[int]=None				,		**UpperCamelCase__      :     Optional[Any]				,		)				->					Optional[int]:
								'''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         =     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         =     getattr(UpperCamelCase_				,		normalizer_state.pop("type"      )      )
														UpperCAmelCase         =     do_lower_case
														UpperCAmelCase         =     strip_accents
														UpperCAmelCase         =     tokenize_chinese_chars
														UpperCAmelCase         =     normalizer_class(**UpperCamelCase_      )

								UpperCAmelCase         =     do_lower_case






		def SCREAMING_SNAKE_CASE_			(						self      :     List[str]				,		UpperCamelCase__      :     Union[str, Any]				,		UpperCamelCase__      :     Dict=None      )				->					Optional[Any]:
								'''simple docstring'''







								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 SCREAMING_SNAKE_CASE_			(						self      :     Any				,		UpperCamelCase__      :     List[int]				,		UpperCamelCase__      :     Optional[List[int]] = None      )				->					List[int]:
								'''simple docstring'''







								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 SCREAMING_SNAKE_CASE_			(						self      :     Dict				,		UpperCamelCase__      :     str				,		UpperCamelCase__      :     Optional[str] = None      )				->					Tuple[str]:
								'''simple docstring'''







								UpperCAmelCase         =     self._tokenizer.model.save(UpperCamelCase_				,		name=UpperCamelCase_      )
								return tuple(UpperCamelCase_      )








def    lowerCamelCase_(lowerCamelCase_ = 600_851_475_143    ) ->       int:

						try:
												UpperCAmelCase         =     int(lowerCamelCase_    )
						except (TypeError, ValueError):
												raise TypeError("Parameter n must be int or castable to int."    )
						if n <= 0:
												raise ValueError("Parameter n must be greater than or equal to one."    )
						UpperCAmelCase         =     1
						UpperCAmelCase         =     2
						while i * i <= n:
												while n % i == 0:
																		UpperCAmelCase         =     i
																		n //= i
												i += 1
						if n > 1:
												UpperCAmelCase         =     n
						return int(lowerCamelCase_    )


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



