"""simple docstring"""







from typing import List, Optional, Tuple

from tokenizers import pre_tokenizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_clip import CLIPTokenizer


_a	:	Union[str, Any]=					logging.get_logger(__name__)

_a	:	Optional[Any]=					{"vocab_file": "vocab.json", "merges_file": "merges.txt", "tokenizer_file": "tokenizer.json"}

_a	:	Optional[int]=					{
    "vocab_file": {
        "openai/clip-vit-base-patch32": "https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/vocab.json",
    },
    "merges_file": {
        "openai/clip-vit-base-patch32": "https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/merges.txt",
    },
    "tokenizer_file": {
        "openai/clip-vit-base-patch32": (
            "https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/tokenizer.json"
        ),
    },
}

_a	:	Dict=					{
    "openai/clip-vit-base-patch32": 77,
}

class 						UpperCamelCase     (       lowercase		):
				UpperCAmelCase							: List[Any]       =						VOCAB_FILES_NAMES
				UpperCAmelCase							: List[Any]       =						PRETRAINED_VOCAB_FILES_MAP
				UpperCAmelCase							: Any       =						PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				UpperCAmelCase							: Optional[Any]       =						["""input_ids""", """attention_mask"""]
				UpperCAmelCase							: Union[str, Any]       =						CLIPTokenizer



				def __init__(self							: int      ,    _A							: List[str]=None      ,    _A							: Optional[Any]=None      ,    _A							: List[str]=None      ,    _A							: str="<|endoftext|>"      ,    _A							: List[Any]="<|startoftext|>"      ,    _A							: int="<|endoftext|>"      ,    _A							: Tuple="<|endoftext|>"      ,    **_A							: Dict      ,    )       ->      Dict:
					super().__init__(
					    _A      ,    _A      ,    tokenizer_file=_A      ,    unk_token=_A      ,    bos_token=_A      ,    eos_token=_A      ,    pad_token=_A      ,    **_A      ,    )

					if not isinstance(self.backend_tokenizer.pre_tokenizer      ,    pre_tokenizers.Sequence):
						raise ValueError(
						    'The `backend_tokenizer` provided does not match the expected format. The CLIP tokenizer has been'
						    ' heavily modified from transformers version 4.17.0. You need to convert the tokenizer you are using'
						    ' to be compatible with this version.The easiest way to do so is'
						    ' `CLIPTokenizerFast.from_pretrained("path_to_local_folder_or_hub_repo, from_slow=True)`. If you want'
						    ' to use your existing tokenizer, you will have to revert to a version prior to 4.17.0 of'
						    ' transformers.')

					self._wrap_decode_method_backend_tokenizer()



				def    _lowercase	(self							: Dict)       ->      Tuple:
					__snake_case     :				Optional[Any] 						=					self.backend_tokenizer.decode

					def new_decode_method(*_A							: Optional[Any]      ,    **_A							: int):
						__snake_case     :				Optional[int] 						=					orig_decode_method(*_A      ,    **_A)
						__snake_case     :				Optional[int] 						=					text.replace(self.backend_tokenizer.model.end_of_word_suffix      ,    ' ').strip()
						return text

					__snake_case     :				List[Any] 						=					new_decode_method



				def    _lowercase	(self							: List[str]      ,    _A							: List[int]      ,    _A							: Optional[List[int]] = None)       ->      List[int]:
					__snake_case     :				Union[str, Any] 						=					[self.bos_token_id]
					__snake_case     :				str 						=					[self.eos_token_id]

					if token_ids_a is None:
						return bos_token + token_ids_a + eos_token
					return bos_token + token_ids_a + eos_token + eos_token + token_ids_a + eos_token



				def    _lowercase	(self							: Optional[Any]      ,    _A							: List[int]      ,    _A							: Optional[List[int]] = None)       ->      List[int]:
					__snake_case     :				str 						=					[self.bos_token_id]
					__snake_case     :				Union[str, Any] 						=					[self.eos_token_id]

					if token_ids_a is None:
						return len(bos_token + token_ids_a + eos_token) * [0]
					return len(bos_token + token_ids_a + eos_token + eos_token + token_ids_a + eos_token) * [0]






				def    _lowercase	(self							: Tuple      ,    _A							: str      ,    _A							: Optional[str] = None)       ->      Tuple[str]:
					__snake_case     :				str 						=					self._tokenizer.model.save(_A      ,    name=_A)
					return tuple(_A)






"""simple docstring"""







def     __UpperCAmelCase							(       UpperCAmelCase_       :							int = 1_00    )				->     int:

	'''simple docstring'''





	__snake_case     :				Any 						=					1
	__snake_case     :				Tuple 						=					0
	for i in range(1     ,				num + 1    ):
		fact *= i

	for j in str(UpperCAmelCase_    ):
		result += int(UpperCAmelCase_    )

	return result


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





