






from typing import Dict, List, Optional

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


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


lowercase  :							int			  =    {
    '''nielsr/canine-s''': 20_48,
}

# Unicode defines 1,114,112 total “codepoints”
lowercase  :							List[Any]			  =    1_11_41_12

# Below: Constants defining canonical codepoints for special, pseudo-characters.
# Copied from https://github.com/google-research/language/blob/master/language/canine/special_codepoints.py
lowercase  :							Dict			  =    0

lowercase  :							str			  =    0xE_000
lowercase  :							Optional[int]			  =    0xE_001
lowercase  :							Dict			  =    0xE_002
lowercase  :							Tuple			  =    0xE_003
lowercase  :							List[Any]			  =    0xE_004

# Maps special codepoints to human-readable names.
lowercase  :							Dict[int, str]			  =    {
    # Special symbols are represented using codepoints values that are valid,
    # but designated as "Private Use", meaning that they will never be assigned
    # characters by the Unicode Consortium, and are thus safe for use here.
    #
    # NOTE: Do *NOT* add any sort of [UNK_CHAR] here. They are explicitly
    # excluded and should fail with a hard error.
    CLS: "[CLS]",
    SEP: "[SEP]",
    BOS: "[BOS]",
    MASK: "[MASK]",
    PAD: "[PAD]",
    RESERVED: "[RESERVED]",
}

# Maps special codepoint human-readable names to their codepoint values.
lowercase  :							Dict[str, int]			  =    {name: codepoint for codepoint, name in SPECIAL_CODEPOINTS.items()}




class 		UpperCAmelCase_						(	SCREAMING_SNAKE_CASE__					):


						'''simple docstring'''




						A     :   List[Any]						=					PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES






						def __init__(	self		,				_SCREAMING_SNAKE_CASE=chr(_SCREAMING_SNAKE_CASE				)		,				_SCREAMING_SNAKE_CASE=chr(_SCREAMING_SNAKE_CASE				)		,				_SCREAMING_SNAKE_CASE=chr(_SCREAMING_SNAKE_CASE				)		,				_SCREAMING_SNAKE_CASE=chr(_SCREAMING_SNAKE_CASE				)		,				_SCREAMING_SNAKE_CASE=chr(_SCREAMING_SNAKE_CASE				)		,				_SCREAMING_SNAKE_CASE=chr(_SCREAMING_SNAKE_CASE				)		,				_SCREAMING_SNAKE_CASE=False		,				_SCREAMING_SNAKE_CASE=2048		,				**_SCREAMING_SNAKE_CASE		,				) ->				List[Any]:
								snake_case_				:							Union[str, Any]						 =       AddedToken(_SCREAMING_SNAKE_CASE		,				lstrip=_SCREAMING_SNAKE_CASE		,				rstrip=_SCREAMING_SNAKE_CASE				) if isinstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				) else bos_token
								snake_case_				:							str						 =       AddedToken(_SCREAMING_SNAKE_CASE		,				lstrip=_SCREAMING_SNAKE_CASE		,				rstrip=_SCREAMING_SNAKE_CASE				) if isinstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				) else eos_token
								snake_case_				:							List[str]						 =       AddedToken(_SCREAMING_SNAKE_CASE		,				lstrip=_SCREAMING_SNAKE_CASE		,				rstrip=_SCREAMING_SNAKE_CASE				) if isinstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				) else sep_token
								snake_case_				:							List[str]						 =       AddedToken(_SCREAMING_SNAKE_CASE		,				lstrip=_SCREAMING_SNAKE_CASE		,				rstrip=_SCREAMING_SNAKE_CASE				) if isinstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				) else cls_token
								snake_case_				:							Any						 =       AddedToken(_SCREAMING_SNAKE_CASE		,				lstrip=_SCREAMING_SNAKE_CASE		,				rstrip=_SCREAMING_SNAKE_CASE				) if isinstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				) else pad_token

								# Mask token behave like a normal word, i.e. include the space before it
								snake_case_				:							str						 =       AddedToken(_SCREAMING_SNAKE_CASE		,				lstrip=_SCREAMING_SNAKE_CASE		,				rstrip=_SCREAMING_SNAKE_CASE				) if isinstance(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				) else mask_token

								super().__init__(
								    bos_token=_SCREAMING_SNAKE_CASE		,				eos_token=_SCREAMING_SNAKE_CASE		,				sep_token=_SCREAMING_SNAKE_CASE		,				cls_token=_SCREAMING_SNAKE_CASE		,				pad_token=_SCREAMING_SNAKE_CASE		,				mask_token=_SCREAMING_SNAKE_CASE		,				add_prefix_space=_SCREAMING_SNAKE_CASE		,				model_max_length=_SCREAMING_SNAKE_CASE		,				**_SCREAMING_SNAKE_CASE		,				)

								# Creates a mapping for looking up the IDs of special symbols.
								snake_case_				:							Dict[str, int]						 =       {}
								for codepoint, name in SPECIAL_CODEPOINTS.items():
										snake_case_				:							Dict						 =       codepoint

								# Creates a mapping for looking up the string forms of special symbol IDs.
								snake_case_				:							Dict[int, str]						 =       {
								    codepoint: name for name, codepoint in self._special_codepoints.items()
								}

								snake_case_				:							Tuple						 =       UNICODE_VOCAB_SIZE
								snake_case_				:							Dict						 =       len(self._special_codepoints				)






						@property
						def       _lowerCAmelCase       (	self				) ->				int:
								return self._unicode_vocab_size






						def       _lowerCAmelCase       (	self		,				_SCREAMING_SNAKE_CASE				) ->				List[str]:
								return list(_SCREAMING_SNAKE_CASE				)






						def       _lowerCAmelCase       (	self		,				_SCREAMING_SNAKE_CASE				) ->				int:
								try:
										return ord(_SCREAMING_SNAKE_CASE				)
								except TypeError:
										raise ValueError(f'''invalid token: \'{token}\''''				)






						def       _lowerCAmelCase       (	self		,				_SCREAMING_SNAKE_CASE				) ->				str:
								try:
										if index in SPECIAL_CODEPOINTS:
												return SPECIAL_CODEPOINTS[index]
										return chr(_SCREAMING_SNAKE_CASE				)
								except TypeError:
										raise ValueError(f'''invalid id: {index}'''				)






						def       _lowerCAmelCase       (	self		,				_SCREAMING_SNAKE_CASE				) ->				Union[str, Any]:
								return "".join(_SCREAMING_SNAKE_CASE				)






						def       _lowerCAmelCase       (	self		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE = None				) ->				List[int]:
								snake_case_				:							List[Any]						 =       [self.sep_token_id]
								snake_case_				:							Optional[int]						 =       [self.cls_token_id]

								snake_case_				:							Any						 =       cls + token_ids_a + sep
								if token_ids_a is not None:
										result += token_ids_a + sep
								return result






						def       _lowerCAmelCase       (	self		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE = None		,				_SCREAMING_SNAKE_CASE = False				) ->				List[int]:
								if already_has_special_tokens:
										return super().get_special_tokens_mask(
										    token_ids_a=_SCREAMING_SNAKE_CASE		,				token_ids_a=_SCREAMING_SNAKE_CASE		,				already_has_special_tokens=_SCREAMING_SNAKE_CASE				)

								snake_case_				:							Optional[Any]						 =       [1] + ([0] * len(_SCREAMING_SNAKE_CASE				)) + [1]
								if token_ids_a is not None:
										result += ([0] * len(_SCREAMING_SNAKE_CASE				)) + [1]
								return result






						def       _lowerCAmelCase       (	self		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE = None				) ->				List[int]:
								snake_case_				:							int						 =       [self.sep_token_id]
								snake_case_				:							Optional[int]						 =       [self.cls_token_id]

								snake_case_				:							str						 =       len(cls + token_ids_a + sep				) * [0]
								if token_ids_a is not None:
										result += len(token_ids_a + sep				) * [1]
								return result






						def       _lowerCAmelCase       (	self		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE = None				) ->				Union[str, Any]:
								return ()








def      lowerCAmelCase__	(    _a       :			int    ):
		snake_case_				:							str						 =       1
		for i in range(1  ,      num + 1    ):
				fact *= i
		return fact

def      lowerCAmelCase__	(    _a       :			int    ):
		snake_case_				:							List[str]						 =       0
		while number > 0:
				snake_case_				:							Dict						 =       number % 10
				sum_of_digits += last_digit
				snake_case_				:							List[Any]						 =       number // 10  # Removing the last_digit from the given number
		return sum_of_digits

def      lowerCAmelCase__	(    _a       :			int = 1_00    ):
		snake_case_				:							Optional[Any]						 =       factorial(_a    )
		snake_case_				:							Optional[int]						 =       split_and_add(_a    )
		return result


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