


import gc
import unittest

import numpy as np
import torch

from diffusers import AutoencoderKL, DDIMScheduler, DiTPipeline, DPMSolverMultistepScheduler, TransformeraDModel
from diffusers.utils import is_xformers_available, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    CLASS_CONDITIONED_IMAGE_GENERATION_BATCH_PARAMS,
    CLASS_CONDITIONED_IMAGE_GENERATION_PARAMS,
)
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()


class 			lowerCamelCase_		(			_UpperCamelCase       ,  unittest.TestCase   ):





				"""simple docstring"""







				_lowerCAmelCase      :      str      							=					DiTPipeline
				_lowerCAmelCase      :      List[Any]      							=					CLASS_CONDITIONED_IMAGE_GENERATION_PARAMS
				_lowerCAmelCase      :      Dict      							=					PipelineTesterMixin.required_optional_params - {
				    "latents",
				    "num_images_per_prompt",
				    "callback",
				    "callback_steps",
				}
				_lowerCAmelCase      :      Any      							=					CLASS_CONDITIONED_IMAGE_GENERATION_BATCH_PARAMS
				_lowerCAmelCase      :      str      							=					False



				def   lowerCAmelCase__		(						self     ):
								torch.manual_seed(0     )
								SCREAMING_SNAKE_CASE__     							=				TransformeraDModel(
								    sample_size=16       ,		num_layers=2       ,		patch_size=4       ,		attention_head_dim=8       ,		num_attention_heads=2       ,		in_channels=4       ,		out_channels=8       ,		attention_bias=__a       ,		activation_fn="gelu-approximate"       ,		num_embeds_ada_norm=1000       ,		norm_type="ada_norm_zero"       ,		norm_elementwise_affine=__a       ,		)
								SCREAMING_SNAKE_CASE__     							=				AutoencoderKL()
								SCREAMING_SNAKE_CASE__     							=				DDIMScheduler()
								SCREAMING_SNAKE_CASE__     							=				{"transformer": transformer.eval(), "vae": vae.eval(), "scheduler": scheduler}
								return components



				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__=0     ):
								if str(__a     ).startswith("mps"     ):
												SCREAMING_SNAKE_CASE__     							=				torch.manual_seed(__a     )
								else:
												SCREAMING_SNAKE_CASE__     							=				torch.Generator(device=__a     ).manual_seed(__a     )
								SCREAMING_SNAKE_CASE__     							=				{
								    "class_labels": [1],
								    "generator": generator,
								    "num_inference_steps": 2,
								    "output_type": "numpy",
								}
								return inputs



				def   lowerCAmelCase__		(						self     ):
								SCREAMING_SNAKE_CASE__     							=				"cpu"

								SCREAMING_SNAKE_CASE__     							=				self.get_dummy_components()
								SCREAMING_SNAKE_CASE__     							=				self.pipeline_class(**__a     )
								pipe.to(__a     )
								pipe.set_progress_bar_config(disable=__a     )

								SCREAMING_SNAKE_CASE__     							=				self.get_dummy_inputs(__a     )
								SCREAMING_SNAKE_CASE__     							=				pipe(**__a     ).images
								SCREAMING_SNAKE_CASE__     							=				image[0, -3:, -3:, -1]

								self.assertEqual(image.shape       ,		(1, 16, 16, 3)     )
								SCREAMING_SNAKE_CASE__     							=				np.array([0.2_946, 0.6_601, 0.4_329, 0.3_296, 0.4_144, 0.5_319, 0.7_273, 0.5_013, 0.4_457]     )
								SCREAMING_SNAKE_CASE__     							=				np.abs(image_slice.flatten() - expected_slice     ).max()
								self.assertLessEqual(__a       ,		1e-3     )



				def   lowerCAmelCase__		(						self     ):
								self._test_inference_batch_single_identical(relax_max_difference=__a       ,		expected_max_diff=1e-3     )






				@unittest.skipIf(
				    torch_device != "cuda" or not is_xformers_available()       ,		reason="XFormers attention is only available with CUDA and `xformers` installed"       ,		)
				def   lowerCAmelCase__		(						self     ):
								self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3     )


@require_torch_gpu
@slow
class 			lowerCamelCase_		(			unittest.TestCase   ):





				"""simple docstring"""







				def   lowerCAmelCase__		(						self     ):
								super().tearDown()
								gc.collect()
								torch.cuda.empty_cache()



				def   lowerCAmelCase__		(						self     ):
								SCREAMING_SNAKE_CASE__     							=				torch.manual_seed(0     )

								SCREAMING_SNAKE_CASE__     							=				DiTPipeline.from_pretrained("facebook/DiT-XL-2-256"     )
								pipe.to("cuda"     )

								SCREAMING_SNAKE_CASE__     							=				["vase", "umbrella", "white shark", "white wolf"]
								SCREAMING_SNAKE_CASE__     							=				pipe.get_label_ids(__a     )

								SCREAMING_SNAKE_CASE__     							=				pipe(__a       ,		generator=__a       ,		num_inference_steps=40       ,		output_type="np"     ).images

								for word, image in zip(__a       ,		__a     ):
												SCREAMING_SNAKE_CASE__     							=				load_numpy(
												    f'''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/dit/{word}.npy'''     )
												assert np.abs((expected_image - image).max()     ) < 1e-2






				def   lowerCAmelCase__		(						self     ):
								SCREAMING_SNAKE_CASE__     							=				DiTPipeline.from_pretrained("facebook/DiT-XL-2-512"     )
								SCREAMING_SNAKE_CASE__     							=				DPMSolverMultistepScheduler.from_config(pipe.scheduler.config     )
								pipe.to("cuda"     )

								SCREAMING_SNAKE_CASE__     							=				["vase", "umbrella"]
								SCREAMING_SNAKE_CASE__     							=				pipe.get_label_ids(__a     )

								SCREAMING_SNAKE_CASE__     							=				torch.manual_seed(0     )
								SCREAMING_SNAKE_CASE__     							=				pipe(__a       ,		generator=__a       ,		num_inference_steps=25       ,		output_type="np"     ).images

								for word, image in zip(__a       ,		__a     ):
												SCREAMING_SNAKE_CASE__     							=				load_numpy(
												    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
												    f'''/dit/{word}_512.npy'''     )

												assert np.abs((expected_image - image).max()     ) < 1e-1




"""simple docstring"""






from math import factorial


def __lowercase     (      lowerCamelCase_  :      int = 100  ):
				return sum(int(lowerCamelCase_  ) for x in str(factorial(lowerCamelCase_  )  )  )


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