


"""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_mobilebert import MobileBertTokenizer


UpperCamelCase__				:Optional[int]			   =	logging.get_logger(__name__)

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

UpperCamelCase__				:int			   =	{
    """vocab_file""": {"""mobilebert-uncased""": """https://huggingface.co/google/mobilebert-uncased/resolve/main/vocab.txt"""},
    """tokenizer_file""": {
        """mobilebert-uncased""": """https://huggingface.co/google/mobilebert-uncased/resolve/main/tokenizer.json"""
    },
}

UpperCamelCase__				:Any			   =	{"""mobilebert-uncased""": 512}


UpperCamelCase__				:Any			   =	{}






class      A(  lowerCamelCase__		):

		"""simple docstring"""





		A    =							VOCAB_FILES_NAMES
		A    =							PRETRAINED_VOCAB_FILES_MAP
		A    =							PRETRAINED_INIT_CONFIGURATION
		A    =							PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
		A    =							MobileBertTokenizer
		def __init__( self					,				SCREAMING_SNAKE_CASE__=None					,				SCREAMING_SNAKE_CASE__=None					,				SCREAMING_SNAKE_CASE__=True					,				SCREAMING_SNAKE_CASE__="[UNK]"					,				SCREAMING_SNAKE_CASE__="[SEP]"					,				SCREAMING_SNAKE_CASE__="[PAD]"					,				SCREAMING_SNAKE_CASE__="[CLS]"					,				SCREAMING_SNAKE_CASE__="[MASK]"					,				SCREAMING_SNAKE_CASE__=True					,				SCREAMING_SNAKE_CASE__=None					,				**SCREAMING_SNAKE_CASE__					,				)      ->	Optional[Any]:

					"""simple docstring"""



					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__					,				)

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

					_UpperCamelCase					:List[str]					     =	do_lower_case
		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__=None   )      ->	Union[str, Any]:

					"""simple docstring"""



					_UpperCamelCase					:List[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   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__ = None   )      ->	List[int]:

					"""simple docstring"""



					_UpperCamelCase					:Optional[Any]					     =	[self.sep_token_id]
					_UpperCamelCase					:Optional[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   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__ = None   )      ->	Tuple[str]:

					"""simple docstring"""



					_UpperCamelCase					:int					     =	self._tokenizer.model.save(SCREAMING_SNAKE_CASE__					,				name=SCREAMING_SNAKE_CASE__   )
					return tuple(SCREAMING_SNAKE_CASE__   )





"""simple docstring"""






def 				A_       ( snake_case__		)					->  int:
			_UpperCamelCase					:Dict					     =	1
			for i in range(1       ,					num + 1		):
						fact *= i
			return fact





def 				A_       ( snake_case__		)					->  int:
			_UpperCamelCase					:Dict					     =	0
			while number > 0:
						_UpperCamelCase					:Tuple					     =	number % 10
						sum_of_digits += last_digit
						_UpperCamelCase					:str					     =	number // 10  # Removing the last_digit from the given number
			return sum_of_digits





def 				A_       ( snake_case__ = 1_00		)					->  int:
			_UpperCamelCase					:int					     =	factorial(snake_case__		)
			_UpperCamelCase					:Dict					     =	split_and_add(snake_case__		)
			return result


if __name__ == "__main__":
					print(solution(int(input("""Enter the Number: """).strip())))

