





import random
import shutil
import tempfile
import unittest

import numpy as np

from transformers import TaTokenizer, TaTokenizerFast
from transformers.testing_utils import require_sentencepiece, require_torch
from transformers.utils.import_utils import is_speech_available, is_torch_available


if is_torch_available():
					pass

if is_speech_available():
					from transformers import EncodecFeatureExtractor, MusicgenProcessor


UpperCAmelCase_   				=  random.Random()





def     lowerCamelCase__  (  UpperCamelCase__      :							Union[str, Any]							,     UpperCamelCase__      :							str=1.0							,     UpperCamelCase__      :							str=None							,     UpperCamelCase__      :							Tuple=None    )      ->			Tuple:



					'''simple docstring'''




					if rng is None:
										_snake_case						=					global_rng

					_snake_case						=					[]
					for batch_idx in range(shape[0]    ):
										values.append([]    )
										for _ in range(shape[1]    ):
															values[-1].append(rng.random() * scale    )

					return values




@require_torch
@require_sentencepiece
class       UpperCamelCase_		(	unittest.TestCase       ):




					def 						lowerCAmelCase      (		self	)		->				List[Any]:
										_snake_case						=					'facebook/musicgen-small'
										_snake_case						=					tempfile.mkdtemp()




					def 						lowerCAmelCase      (		self					,    **lowerCAmelCase_	)		->				List[str]:
										return TaTokenizer.from_pretrained(self.checkpoint					,    **lowerCAmelCase_	)




					def 						lowerCAmelCase      (		self					,    **lowerCAmelCase_	)		->				Dict:
										return EncodecFeatureExtractor.from_pretrained(self.checkpoint					,    **lowerCAmelCase_	)




					def 						lowerCAmelCase      (		self	)		->				Dict:
										shutil.rmtree(self.tmpdirname	)




					def 						lowerCAmelCase      (		self	)		->				List[Any]:
										_snake_case						=					self.get_tokenizer()
										_snake_case						=					self.get_feature_extractor()

										_snake_case						=					MusicgenProcessor(tokenizer=lowerCAmelCase_					,    feature_extractor=lowerCAmelCase_	)

										processor.save_pretrained(self.tmpdirname	)
										_snake_case						=					MusicgenProcessor.from_pretrained(self.tmpdirname	)

										self.assertEqual(processor.tokenizer.get_vocab()					,    tokenizer.get_vocab()	)
										self.assertIsInstance(processor.tokenizer					,    lowerCAmelCase_	)

										self.assertEqual(processor.feature_extractor.to_json_string()					,    feature_extractor.to_json_string()	)
										self.assertIsInstance(processor.feature_extractor					,    lowerCAmelCase_	)




					def 						lowerCAmelCase      (		self	)		->				Any:
										_snake_case						=					MusicgenProcessor(tokenizer=self.get_tokenizer()					,    feature_extractor=self.get_feature_extractor()	)
										processor.save_pretrained(self.tmpdirname	)

										_snake_case						=					self.get_tokenizer(bos_token='(BOS)'					,    eos_token='(EOS)'	)
										_snake_case						=					self.get_feature_extractor(do_normalize=lowerCAmelCase_					,    padding_value=1.0	)

										_snake_case						=					MusicgenProcessor.from_pretrained(
										    self.tmpdirname					,    bos_token='(BOS)'					,    eos_token='(EOS)'					,    do_normalize=lowerCAmelCase_					,    padding_value=1.0	)

										self.assertEqual(processor.tokenizer.get_vocab()					,    tokenizer_add_kwargs.get_vocab()	)
										self.assertIsInstance(processor.tokenizer					,    lowerCAmelCase_	)

										self.assertEqual(processor.feature_extractor.to_json_string()					,    feature_extractor_add_kwargs.to_json_string()	)
										self.assertIsInstance(processor.feature_extractor					,    lowerCAmelCase_	)




					def 						lowerCAmelCase      (		self	)		->				Dict:
										_snake_case						=					self.get_feature_extractor()
										_snake_case						=					self.get_tokenizer()

										_snake_case						=					MusicgenProcessor(tokenizer=lowerCAmelCase_					,    feature_extractor=lowerCAmelCase_	)

										_snake_case						=					floats_list((3, 1000)	)

										_snake_case						=					feature_extractor(lowerCAmelCase_					,    return_tensors='np'	)
										_snake_case						=					processor(lowerCAmelCase_					,    return_tensors='np'	)

										for key in input_feat_extract.keys():
															self.assertAlmostEqual(input_feat_extract[key].sum()					,    input_processor[key].sum()					,    delta=1E-2	)




					def 						lowerCAmelCase      (		self	)		->				Optional[int]:
										_snake_case						=					self.get_feature_extractor()
										_snake_case						=					self.get_tokenizer()

										_snake_case						=					MusicgenProcessor(tokenizer=lowerCAmelCase_					,    feature_extractor=lowerCAmelCase_	)

										_snake_case						=					'This is a test string'

										_snake_case						=					processor(text=lowerCAmelCase_	)

										_snake_case						=					tokenizer(lowerCAmelCase_	)

										for key in encoded_tok.keys():
															self.assertListEqual(encoded_tok[key]					,    encoded_processor[key]	)




					def 						lowerCAmelCase      (		self	)		->				Any:
										_snake_case						=					self.get_feature_extractor()
										_snake_case						=					self.get_tokenizer()

										_snake_case						=					MusicgenProcessor(tokenizer=lowerCAmelCase_					,    feature_extractor=lowerCAmelCase_	)

										_snake_case						=					[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

										_snake_case						=					processor.batch_decode(sequences=lowerCAmelCase_	)
										_snake_case						=					tokenizer.batch_decode(lowerCAmelCase_	)

										self.assertListEqual(lowerCAmelCase_					,    lowerCAmelCase_	)




					def 						lowerCAmelCase      (		self	)		->				List[str]:
										_snake_case						=					self.get_feature_extractor()
										_snake_case						=					self.get_tokenizer()

										_snake_case						=					MusicgenProcessor(tokenizer=lowerCAmelCase_					,    feature_extractor=lowerCAmelCase_	)

										self.assertListEqual(
										    processor.model_input_names					,    feature_extractor.model_input_names					,    msg='`processor` and `feature_extractor` model input names do not match'					,    )






					def 						lowerCAmelCase      (		self	)		->				Union[str, Any]:
										_snake_case						=					self.get_feature_extractor(padding_side='left'	)
										_snake_case						=					self.get_tokenizer()

										_snake_case						=					MusicgenProcessor(tokenizer=lowerCAmelCase_					,    feature_extractor=lowerCAmelCase_	)

										_snake_case						=					[floats_list((1, x)	)[0] for x in range(5					,    20					,    5	)]
										_snake_case						=					processor(lowerCAmelCase_	).padding_mask

										_snake_case						=					np.asarray(floats_list((3, 20)	)	)[:, None, :]
										_snake_case						=					processor.batch_decode(lowerCAmelCase_					,    padding_mask=lowerCAmelCase_	)

										self.assertIsInstance(lowerCAmelCase_					,    lowerCAmelCase_	)

										for audio in decoded_audios:
															self.assertIsInstance(lowerCAmelCase_					,    np.ndarray	)

										self.assertTrue(decoded_audios[0].shape == (1, 10)	)
										self.assertTrue(decoded_audios[1].shape == (1, 15)	)
										self.assertTrue(decoded_audios[2].shape == (1, 20)	)










def     lowerCamelCase__  (  UpperCamelCase__      :							int = 100    )      ->			int:



					'''simple docstring'''




					_snake_case						=					1
					_snake_case						=					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())))



