

import json
import os
import unittest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_ftfy, require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin

@require_tokenizers
class 					a__						(					snake_case_							,	unittest.TestCase			):
			"""simple docstring"""







			__lowerCamelCase        =       CLIPTokenizer
			__lowerCamelCase        =       CLIPTokenizerFast
			__lowerCamelCase        =       True
			__lowerCamelCase        =       {}
			__lowerCamelCase        =       False


			def      UpperCamelCase		(    self       )  ->						int:
							'''simple docstring'''






							super().setUp()

							# fmt: off
							A__        =			["l", "o", "w", "e", "r", "s", "t", "i", "d", "n", "lo", "l</w>", "w</w>", "r</w>", "t</w>", "low</w>", "er</w>", "lowest</w>", "newer</w>", "wider", "<unk>", "<|startoftext|>", "<|endoftext|>"]
							# fmt: on
							A__        =			dict(zip(lowercase      ,      range(len(lowercase       )       )       )       )
							A__        =			["#version: 0.2", "l o", "lo w</w>", "e r</w>"]
							A__        =			{"unk_token": "<unk>"}

							A__        =			os.path.join(self.tmpdirname      ,      VOCAB_FILES_NAMES["vocab_file"]       )
							A__        =			os.path.join(self.tmpdirname      ,      VOCAB_FILES_NAMES["merges_file"]       )
							with open(self.vocab_file      ,      "w"      ,      encoding="utf-8"       ) as fp:
											fp.write(json.dumps(lowercase       ) + "\n"       )
							with open(self.merges_file      ,      "w"      ,      encoding="utf-8"       ) as fp:
											fp.write("\n".join(lowercase       )       )


			def      UpperCamelCase		(    self      ,      **lowercase       )  ->						Tuple:
							'''simple docstring'''






							kwargs.update(self.special_tokens_map       )
							return CLIPTokenizer.from_pretrained(self.tmpdirname      ,      **lowercase       )


			def      UpperCamelCase		(    self      ,      **lowercase       )  ->						Any:
							'''simple docstring'''






							kwargs.update(self.special_tokens_map       )
							return CLIPTokenizerFast.from_pretrained(self.tmpdirname      ,      **lowercase       )


			def      UpperCamelCase		(    self      ,      lowercase       )  ->						int:
							'''simple docstring'''






							A__        =			"lower newer"
							A__        =			"lower newer"
							return input_text, output_text


			def      UpperCamelCase		(    self       )  ->						Optional[Any]:
							'''simple docstring'''






							A__        =			CLIPTokenizer(self.vocab_file      ,      self.merges_file      ,      **self.special_tokens_map       )
							A__        =			"lower newer"
							A__        =			["lo", "w", "er</w>", "n", "e", "w", "er</w>"]
							A__        =			tokenizer.tokenize(lowercase       )
							self.assertListEqual(lowercase      ,      lowercase       )

							A__        =			tokens + [tokenizer.unk_token]
							A__        =			[10, 2, 16, 9, 3, 2, 16, 20]
							self.assertListEqual(tokenizer.convert_tokens_to_ids(lowercase       )      ,      lowercase       )


			@require_ftfy
			def      UpperCamelCase		(    self       )  ->						Optional[Any]:
							'''simple docstring'''






							for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
											with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})'       ):
															A__        =			self.tokenizer_class.from_pretrained(lowercase      ,      **lowercase       )
															A__        =			self.rust_tokenizer_class.from_pretrained(lowercase      ,      **lowercase       )

															A__        =			"A\n'll 11p223RF☆ho!!to?'d'd''d of a cat to-$''d."
															A__        =			tokenizer_s.tokenize(lowercase       )
															A__        =			tokenizer_r.tokenize(lowercase       )

															self.assertListEqual(lowercase      ,      lowercase       )

															# Test that the tokenization is identical on an example containing a character (Latin Small Letter A
															# with Tilde) encoded in 2 different ways
															A__        =			"xa\u0303y" + " " + "x\xe3y"
															A__        =			tokenizer_s.tokenize(lowercase       )
															A__        =			tokenizer_r.tokenize(lowercase       )

															self.assertListEqual(lowercase      ,      lowercase       )

															# Test that the tokenization is identical on unicode of space type
															A__        =			[
															    "\u0009",  # (horizontal tab, '\t')
															    "\u000B",  # (vertical tab)
															    "\u000C",  # (form feed)
															    "\u0020",  # (space, ' ')
															    "\u200E",  # (left-to-right mark):w
															    "\u200F",  # (right-to-left mark)
															]
															for unicode_seq in spaces_unicodes:
																			A__        =			tokenizer_s.tokenize(lowercase       )
																			A__        =			tokenizer_r.tokenize(lowercase       )

																			self.assertListEqual(lowercase      ,      lowercase       )

															# Test that the tokenization is identical on unicode of line break type
															A__        =			[
															    "\u000A",  # (line feed, '\n')
															    "\r\n",  # (carriage return and line feed, '\r\n')
															    "\u000D",  # (carriage return, '\r')
															    "\r",  # (carriage return, '\r')
															    "\u000D",  # (carriage return, '\r')
															    "\u2028",  # (line separator)
															    "\u2029",  # (paragraph separator)
															    # "\u0085", # (next line)
															]

															# The tokenization is not identical for the character "\u0085" (next line). The slow version using ftfy transforms
															# it into the Horizontal Ellipsis character "…" ("\u2026") while the fast version transforms it into a
															# space (and thus into an empty list).

															for unicode_seq in line_break_unicodes:
																			A__        =			tokenizer_s.tokenize(lowercase       )
																			A__        =			tokenizer_r.tokenize(lowercase       )

																			self.assertListEqual(lowercase      ,      lowercase       )


			def      UpperCamelCase		(    self       )  ->						int:
							'''simple docstring'''






							for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
											with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})'       ):
															A__        =			"hello"  # `hello` is a token in the vocabulary of `pretrained_name`
															A__        =			F'{text_of_1_token} {text_of_1_token}'

															A__        =			self.rust_tokenizer_class.from_pretrained(
															    lowercase      ,      use_fast=lowercase      ,      )
															A__        =			tokenizer_r(lowercase      ,      return_offsets_mapping=lowercase      ,      add_special_tokens=lowercase       )
															self.assertEqual(encoding.offset_mapping[0]      ,      (0, len(lowercase       ))       )
															self.assertEqual(
															    encoding.offset_mapping[1]      ,      (len(lowercase       ) + 1, len(lowercase       ) + 1 + len(lowercase       ))      ,      )

															A__        =			F' {text}'

															A__        =			self.rust_tokenizer_class.from_pretrained(
															    lowercase      ,      use_fast=lowercase      ,      )
															A__        =			tokenizer_r(lowercase      ,      return_offsets_mapping=lowercase      ,      add_special_tokens=lowercase       )
															self.assertEqual(encoding.offset_mapping[0]      ,      (1, 1 + len(lowercase       ))       )
															self.assertEqual(
															    encoding.offset_mapping[1]      ,      (1 + len(lowercase       ) + 1, 1 + len(lowercase       ) + 1 + len(lowercase       ))      ,      )


			def      UpperCamelCase		(    self       )  ->						List[Any]:
							'''simple docstring'''






							with self.assertRaises(lowercase       ) as context:
											self.rust_tokenizer_class.from_pretrained("robot-test/old-clip-tokenizer"       )

							self.assertTrue(
							    context.exception.args[0].startswith(
							        "The `backend_tokenizer` provided does not match the expected format."       )       )


			@require_ftfy
			def      UpperCamelCase		(    self       )  ->						List[Any]:
							'''simple docstring'''






							super().test_tokenization_python_rust_equals()


			def      UpperCamelCase		(    self       )  ->						List[Any]:
							'''simple docstring'''






							pass


from math import factorial



def 					lowerCAmelCase__							(	SCREAMING_SNAKE_CASE_:							int = 1_0_0      )			->      int:




				'''simple docstring'''





				return sum(map(SCREAMING_SNAKE_CASE_	,       str(factorial(SCREAMING_SNAKE_CASE_      )      )      )      )


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

