

from __future__ import annotations

import unittest

from transformers import AutoTokenizer, MBartConfig, is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
	import tensorflow as tf

	from transformers import TFAutoModelForSeqaSeqLM, TFMBartForConditionalGeneration, TFMBartModel

@require_tf
class 					a__						:
			"""simple docstring"""







			__lowerCamelCase        =       MBartConfig
			__lowerCamelCase        =       {}
			__lowerCamelCase        =       'gelu'


			def __init__(    self      ,      lowercase      ,      lowercase=13      ,      lowercase=7      ,      lowercase=True      ,      lowercase=False      ,      lowercase=99      ,      lowercase=32      ,      lowercase=2      ,      lowercase=4      ,      lowercase=37      ,      lowercase=0.1      ,      lowercase=0.1      ,      lowercase=20      ,      lowercase=2      ,      lowercase=1      ,      lowercase=0      ,      )  ->						Optional[Any]:
							'''simple docstring'''






							A__        =			parent
							A__        =			batch_size
							A__        =			seq_length
							A__        =			is_training
							A__        =			use_labels
							A__        =			vocab_size
							A__        =			hidden_size
							A__        =			num_hidden_layers
							A__        =			num_attention_heads
							A__        =			intermediate_size
							A__        =			hidden_dropout_prob
							A__        =			attention_probs_dropout_prob
							A__        =			max_position_embeddings
							A__        =			eos_token_id
							A__        =			pad_token_id
							A__        =			bos_token_id


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






							A__        =			ids_tensor([self.batch_size, self.seq_length - 1]      ,      self.vocab_size       )
							A__        =			tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size       )      ,      1       )
							A__        =			tf.concat([input_ids, eos_tensor]      ,      axis=1       )

							A__        =			ids_tensor([self.batch_size, self.seq_length]      ,      self.vocab_size       )

							A__        =			self.config_cls(
							    vocab_size=self.vocab_size      ,      d_model=self.hidden_size      ,      encoder_layers=self.num_hidden_layers      ,      decoder_layers=self.num_hidden_layers      ,      encoder_attention_heads=self.num_attention_heads      ,      decoder_attention_heads=self.num_attention_heads      ,      encoder_ffn_dim=self.intermediate_size      ,      decoder_ffn_dim=self.intermediate_size      ,      dropout=self.hidden_dropout_prob      ,      attention_dropout=self.attention_probs_dropout_prob      ,      max_position_embeddings=self.max_position_embeddings      ,      eos_token_ids=[2]      ,      bos_token_id=self.bos_token_id      ,      pad_token_id=self.pad_token_id      ,      decoder_start_token_id=self.pad_token_id      ,      **self.config_updates      ,      )
							A__        =			prepare_mbart_inputs_dict(lowercase      ,      lowercase      ,      lowercase       )
							return config, inputs_dict


			def      UpperCamelCase		(    self      ,      lowercase      ,      lowercase       )  ->						Union[str, Any]:
							'''simple docstring'''






							A__        =			TFMBartModel(config=lowercase       ).get_decoder()
							A__        =			inputs_dict["input_ids"]

							A__        =			input_ids[:1, :]
							A__        =			inputs_dict["attention_mask"][:1, :]
							A__        =			inputs_dict["head_mask"]
							A__        =			1

							# first forward pass
							A__        =			model(lowercase      ,      attention_mask=lowercase      ,      head_mask=lowercase      ,      use_cache=lowercase       )

							A__    ,				A__        =			outputs.to_tuple()
							A__        =			past_key_values[1]



def 					lowerCAmelCase__							(	SCREAMING_SNAKE_CASE_:							Optional[Any]	,       SCREAMING_SNAKE_CASE_:							Optional[Any]	,       SCREAMING_SNAKE_CASE_:							List[str]	,       SCREAMING_SNAKE_CASE_:							str=None	,       SCREAMING_SNAKE_CASE_:							Union[str, Any]=None	,       SCREAMING_SNAKE_CASE_:							List[Any]=None	,       SCREAMING_SNAKE_CASE_:							int=None	,       SCREAMING_SNAKE_CASE_:							Dict=None	,       )			->      Dict:




				'''simple docstring'''





				if attention_mask is None:
								A__        =			tf.cast(tf.math.not_equal(SCREAMING_SNAKE_CASE_	,       config.pad_token_id      )	,       tf.inta      )
				if decoder_attention_mask is None:
								A__        =			tf.concat(
								    [
								        tf.ones(decoder_input_ids[:, :1].shape	,       dtype=tf.inta      ),
								        tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:]	,       config.pad_token_id      )	,       tf.inta      ),
								    ]	,       axis=-1	,       )
				if head_mask is None:
								A__        =			tf.ones((config.encoder_layers, config.encoder_attention_heads)      )
				if decoder_head_mask is None:
								A__        =			tf.ones((config.decoder_layers, config.decoder_attention_heads)      )
				if cross_attn_head_mask is None:
								A__        =			tf.ones((config.decoder_layers, config.decoder_attention_heads)      )
				return {
				    "input_ids": input_ids,
				    "decoder_input_ids": decoder_input_ids,
				    "attention_mask": attention_mask,
				    "decoder_attention_mask": decoder_attention_mask,
				    "head_mask": head_mask,
				    "decoder_head_mask": decoder_head_mask,
				    "cross_attn_head_mask": cross_attn_head_mask,
				}

@require_tf
class 					a__						(					snake_case							,	snake_case							,	unittest.TestCase			):
			"""simple docstring"""







			__lowerCamelCase        =       (TFMBartForConditionalGeneration, TFMBartModel) if is_tf_available() else ()
			__lowerCamelCase        =       (TFMBartForConditionalGeneration,) if is_tf_available() else ()
			__lowerCamelCase        =       (
			    {
			        'conversational': TFMBartForConditionalGeneration,
			        'feature-extraction': TFMBartModel,
			        'summarization': TFMBartForConditionalGeneration,
			        'text2text-generation': TFMBartForConditionalGeneration,
			        'translation': TFMBartForConditionalGeneration,
			    }
			    if is_tf_available()
			    else {}
			)
			__lowerCamelCase        =       True
			__lowerCamelCase        =       False
			__lowerCamelCase        =       False


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






							if pipeline_test_casse_name != "FeatureExtractionPipelineTests":
											# Exception encountered when calling layer '...'
											return True

							return False


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






							A__        =			TFMBartModelTester(self       )
							A__        =			ConfigTester(self      ,      config_class=lowercase       )


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






							self.config_tester.run_common_tests()


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






							A__        =			self.model_tester.prepare_config_and_inputs_for_common()
							self.model_tester.check_decoder_model_past_large_inputs(*lowercase       )

@require_sentencepiece
@require_tokenizers
@require_tf
class 					a__						(					unittest.TestCase			):
			"""simple docstring"""







			__lowerCamelCase        =       [
			    ' UN Chief Says There Is No Military Solution in Syria',
			]
			__lowerCamelCase        =       [
			    'Şeful ONU declară că nu există o soluţie militară în Siria',
			]
			__lowerCamelCase        =       'facebook/mbart-large-en-ro'


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






							return AutoTokenizer.from_pretrained(self.model_name       )


			@cached_property
			def      UpperCamelCase		(    self       )  ->						Tuple:
							'''simple docstring'''






							A__        =			TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name       )
							return model


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






							A__        =			self.translate_src_text(**lowercase       )
							self.assertListEqual(self.expected_text      ,      lowercase       )


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






							A__        =			self.tokenizer(self.src_text      ,      **lowercase      ,      return_tensors="tf"       )
							A__        =			self.model.generate(
							    model_inputs.input_ids      ,      attention_mask=model_inputs.attention_mask      ,      num_beams=2       )
							A__        =			self.tokenizer.batch_decode(lowercase      ,      skip_special_tokens=lowercase       )
							return generated_words


			@slow
			def      UpperCamelCase		(    self       )  ->						List[str]:
							'''simple docstring'''






							self._assert_generated_batch_equal_expected()




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())))

