




import json
import os
import unittest

from transformers import BatchEncoding, LEDTokenizer, LEDTokenizerFast
from transformers.models.led.tokenization_led import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, require_torch
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin
@require_tokenizers
class 						UpperCAmelCase  (							UpperCAmelCase__			,  unittest.TestCase     ):







						'''simple docstring'''





						lowerCAmelCase_							=  LEDTokenizer
						lowerCAmelCase_							=  LEDTokenizerFast
						lowerCAmelCase_							=  True






						def 			snake_case__		(		self				:	Optional[Any]		):






							"""simple docstring"""






							super().setUp()
							snake_case_						       =	[
							    "l",
							    "o",
							    "w",
							    "e",
							    "r",
							    "s",
							    "t",
							    "i",
							    "d",
							    "n",
							    "\u0120",
							    "\u0120l",
							    "\u0120n",
							    "\u0120lo",
							    "\u0120low",
							    "er",
							    "\u0120lowest",
							    "\u0120newer",
							    "\u0120wider",
							    "<unk>",
							]
							snake_case_						       =	dict(zip(__lowercase			,      range(len(__lowercase		)		)		)		)
							snake_case_						       =	["#version: 0.2", "\u0120 l", "\u0120l o", "\u0120lo w", "e r", ""]
							snake_case_						       =	{"unk_token": "<unk>"}

							snake_case_						       =	os.path.join(self.tmpdirname			,      VOCAB_FILES_NAMES["vocab_file"]		)
							snake_case_						       =	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 			snake_case__		(		self				:	Optional[int]			,      **__lowercase				:	Optional[int]		):






							"""simple docstring"""






							kwargs.update(self.special_tokens_map		)
							return self.tokenizer_class.from_pretrained(self.tmpdirname			,      **__lowercase		)






						def 			snake_case__		(		self				:	Dict			,      **__lowercase				:	Tuple		):






							"""simple docstring"""






							kwargs.update(self.special_tokens_map		)
							return self.rust_tokenizer_class.from_pretrained(self.tmpdirname			,      **__lowercase		)






						def 			snake_case__		(		self				:	List[Any]			,      __lowercase				:	int		):






							"""simple docstring"""






							return "lower newer", "lower newer"






						@cached_property
						def 			snake_case__		(		self				:	List[Any]		):






							"""simple docstring"""






							return LEDTokenizer.from_pretrained("allenai/led-base-16384"		)






						@cached_property
						def 			snake_case__		(		self				:	List[Any]		):






							"""simple docstring"""






							return LEDTokenizerFast.from_pretrained("allenai/led-base-16384"		)






						@require_torch
						def 			snake_case__		(		self				:	Optional[Any]		):






							"""simple docstring"""






							snake_case_						       =	["A long paragraph for summarization.", "Another paragraph for summarization."]
							snake_case_						       =	[0, 2_50, 2_51, 1_78_18, 13, 3_91_86, 19_38, 4, 2]

							for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
								snake_case_						       =	tokenizer(__lowercase			,      max_length=len(__lowercase		)			,      padding=__lowercase			,      return_tensors="pt"		)
								self.assertIsInstance(__lowercase			,      __lowercase		)

								self.assertEqual((2, 9)			,      batch.input_ids.shape		)
								self.assertEqual((2, 9)			,      batch.attention_mask.shape		)
								snake_case_						       =	batch.input_ids.tolist()[0]
								self.assertListEqual(__lowercase			,      __lowercase		)






						@require_torch
						def 			snake_case__		(		self				:	List[str]		):






							"""simple docstring"""






							snake_case_						       =	["A long paragraph for summarization.", "Another paragraph for summarization."]
							for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
								snake_case_						       =	tokenizer(__lowercase			,      padding=__lowercase			,      return_tensors="pt"		)
								self.assertIn("input_ids"			,      __lowercase		)
								self.assertIn("attention_mask"			,      __lowercase		)
								self.assertNotIn("labels"			,      __lowercase		)
								self.assertNotIn("decoder_attention_mask"			,      __lowercase		)






						@require_torch
						def 			snake_case__		(		self				:	List[Any]		):






							"""simple docstring"""






							snake_case_						       =	[
							    "Summary of the text.",
							    "Another summary.",
							]
							for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
								snake_case_						       =	tokenizer(text_target=__lowercase			,      max_length=32			,      padding="max_length"			,      return_tensors="pt"		)
								self.assertEqual(32			,      targets["input_ids"].shape[1]		)






						@require_torch
						def 			snake_case__		(		self				:	Tuple		):






							"""simple docstring"""






							for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
								snake_case_						       =	tokenizer(
								    ["I am a small frog" * 10_24, "I am a small frog"]			,      padding=__lowercase			,      truncation=__lowercase			,      return_tensors="pt"		)
								self.assertIsInstance(__lowercase			,      __lowercase		)
								self.assertEqual(batch.input_ids.shape			,      (2, 51_22)		)






						@require_torch
						def 			snake_case__		(		self				:	int		):






							"""simple docstring"""






							snake_case_						       =	["A long paragraph for summarization."]
							snake_case_						       =	[
							    "Summary of the text.",
							]
							for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
								snake_case_						       =	tokenizer(__lowercase			,      return_tensors="pt"		)
								snake_case_						       =	tokenizer(text_target=__lowercase			,      return_tensors="pt"		)
								snake_case_						       =	inputs["input_ids"]
								snake_case_						       =	targets["input_ids"]
								self.assertTrue((input_ids[:, 0] == tokenizer.bos_token_id).all().item()		)
								self.assertTrue((labels[:, 0] == tokenizer.bos_token_id).all().item()		)
								self.assertTrue((input_ids[:, -1] == tokenizer.eos_token_id).all().item()		)
								self.assertTrue((labels[:, -1] == tokenizer.eos_token_id).all().item()		)






						@require_torch
						def 			snake_case__		(		self				:	Optional[Any]		):






							"""simple docstring"""






							for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
								snake_case_						       =	["Summary of the text.", "Another summary."]
								snake_case_						       =	[[0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, -1, -1]]

								snake_case_						       =	tokenizer(__lowercase			,      padding=__lowercase		)
								snake_case_						       =	[[0] * len(__lowercase		) for x in encoded_output["input_ids"]]
								snake_case_						       =	tokenizer.pad(__lowercase		)
								self.assertSequenceEqual(outputs["global_attention_mask"]			,      __lowercase		)






						def 			snake_case__		(		self				:	Any		):






							"""simple docstring"""






							pass






						def 			snake_case__		(		self				:	Optional[Any]		):






							"""simple docstring"""






							for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
								with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})"		):
									snake_case_						       =	self.rust_tokenizer_class.from_pretrained(__lowercase			,      **__lowercase		)
									snake_case_						       =	self.tokenizer_class.from_pretrained(__lowercase			,      **__lowercase		)
									snake_case_						       =	"A, <mask> AllenNLP sentence."
									snake_case_						       =	tokenizer_r.encode_plus(__lowercase			,      add_special_tokens=__lowercase			,      return_token_type_ids=__lowercase		)
									snake_case_						       =	tokenizer_p.encode_plus(__lowercase			,      add_special_tokens=__lowercase			,      return_token_type_ids=__lowercase		)
									self.assertEqual(sum(tokens_r["token_type_ids"]		)			,      sum(tokens_p["token_type_ids"]		)		)
									self.assertEqual(
									    sum(tokens_r["attention_mask"]		) / len(tokens_r["attention_mask"]		)			,      sum(tokens_p["attention_mask"]		) / len(tokens_p["attention_mask"]		)			,      )

									snake_case_						       =	tokenizer_r.convert_ids_to_tokens(tokens_r["input_ids"]		)
									snake_case_						       =	tokenizer_p.convert_ids_to_tokens(tokens_p["input_ids"]		)
									self.assertSequenceEqual(tokens_p["input_ids"]			,      [0, 2_50, 6, 5_02_64, 38_23, 4_87, 2_19_92, 36_45, 4, 2]		)
									self.assertSequenceEqual(tokens_r["input_ids"]			,      [0, 2_50, 6, 5_02_64, 38_23, 4_87, 2_19_92, 36_45, 4, 2]		)

									self.assertSequenceEqual(
									    __lowercase			,      ["<s>", "A", ",", "<mask>", "ĠAllen", "N", "LP", "Ġsentence", ".", "</s>"]		)
									self.assertSequenceEqual(
									    __lowercase			,      ["<s>", "A", ",", "<mask>", "ĠAllen", "N", "LP", "Ġsentence", ".", "</s>"]		)






def 		lowerCamelCase__       (						_A				):







	'''simple docstring'''





	snake_case_						       =	1
	for i in range(1	,      num + 1				):
		fact *= i
	return fact


def 		lowerCamelCase__       (						_A				):







	'''simple docstring'''





	snake_case_						       =	0
	while number > 0:
		snake_case_						       =	number % 10
		sum_of_digits += last_digit
		snake_case_						       =	number // 10  # Removing the last_digit from the given number
	return sum_of_digits


def 		lowerCamelCase__       (						_A = 100				):







	'''simple docstring'''





	snake_case_						       =	factorial(_A				)
	snake_case_						       =	split_and_add(_A				)
	return result


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