

import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image

from diffusers import (
    DDIMScheduler,
    KandinskyVaaControlnetImgaImgPipeline,
    KandinskyVaaPriorEmbaEmbPipeline,
    UNetaDConditionModel,
    VQModel,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()

class 					a__						(					__UpperCAmelCase							,	unittest.TestCase			):
			"""simple docstring"""







			__lowerCamelCase        =       KandinskyVaaControlnetImgaImgPipeline
			__lowerCamelCase        =       ["image_embeds", "negative_image_embeds", "image", "hint"]
			__lowerCamelCase        =       ["image_embeds", "negative_image_embeds", "image", "hint"]
			__lowerCamelCase        =       [
			    "generator",
			    "height",
			    "width",
			    "strength",
			    "guidance_scale",
			    "num_inference_steps",
			    "return_dict",
			    "guidance_scale",
			    "num_images_per_prompt",
			    "output_type",
			    "return_dict",
			]
			__lowerCamelCase        =       False


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






							return 32


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






							return 32


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






							return self.time_input_dim


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






							return self.time_input_dim * 4


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






							return 100


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






							torch.manual_seed(0       )

							A__        =			{
							    "in_channels": 8,
							    # Out channels is double in channels because predicts mean and variance
							    "out_channels": 8,
							    "addition_embed_type": "image_hint",
							    "down_block_types": ("ResnetDownsampleBlock2D", "SimpleCrossAttnDownBlock2D"),
							    "up_block_types": ("SimpleCrossAttnUpBlock2D", "ResnetUpsampleBlock2D"),
							    "mid_block_type": "UNetMidBlock2DSimpleCrossAttn",
							    "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
							    "layers_per_block": 1,
							    "encoder_hid_dim": self.text_embedder_hidden_size,
							    "encoder_hid_dim_type": "image_proj",
							    "cross_attention_dim": self.cross_attention_dim,
							    "attention_head_dim": 4,
							    "resnet_time_scale_shift": "scale_shift",
							    "class_embed_type": None,
							}

							A__        =			UNetaDConditionModel(**_lowerCamelCase       )
							return model


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






							return {
							    "block_out_channels": [32, 32, 64, 64],
							    "down_block_types": [
							        "DownEncoderBlock2D",
							        "DownEncoderBlock2D",
							        "DownEncoderBlock2D",
							        "AttnDownEncoderBlock2D",
							    ],
							    "in_channels": 3,
							    "latent_channels": 4,
							    "layers_per_block": 1,
							    "norm_num_groups": 8,
							    "norm_type": "spatial",
							    "num_vq_embeddings": 12,
							    "out_channels": 3,
							    "up_block_types": ["AttnUpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D"],
							    "vq_embed_dim": 4,
							}


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






							torch.manual_seed(0       )
							A__        =			VQModel(**self.dummy_movq_kwargs       )
							return model


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






							A__        =			self.dummy_unet
							A__        =			self.dummy_movq

							A__        =			{
							    "num_train_timesteps": 1000,
							    "beta_schedule": "linear",
							    "beta_start": 0.0_0085,
							    "beta_end": 0.012,
							    "clip_sample": False,
							    "set_alpha_to_one": False,
							    "steps_offset": 0,
							    "prediction_type": "epsilon",
							    "thresholding": False,
							}

							A__        =			DDIMScheduler(**_lowerCamelCase       )

							A__        =			{
							    "unet": unet,
							    "scheduler": scheduler,
							    "movq": movq,
							}

							return components


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






							A__        =			floats_tensor((1, self.text_embedder_hidden_size)      ,      rng=random.Random(_lowerCamelCase       )       ).to(_lowerCamelCase       )
							A__        =			floats_tensor((1, self.text_embedder_hidden_size)      ,      rng=random.Random(seed + 1       )       ).to(
							    _lowerCamelCase       )
							# create init_image
							A__        =			floats_tensor((1, 3, 64, 64)      ,      rng=random.Random(_lowerCamelCase       )       ).to(_lowerCamelCase       )
							A__        =			image.cpu().permute(0      ,      2      ,      3      ,      1       )[0]
							A__        =			Image.fromarray(np.uinta(_lowerCamelCase       )       ).convert("RGB"       ).resize((256, 256)       )
							# create hint
							A__        =			floats_tensor((1, 3, 64, 64)      ,      rng=random.Random(_lowerCamelCase       )       ).to(_lowerCamelCase       )

							if str(_lowerCamelCase       ).startswith("mps"       ):
											A__        =			torch.manual_seed(_lowerCamelCase       )
							else:
											A__        =			torch.Generator(device=_lowerCamelCase       ).manual_seed(_lowerCamelCase       )
							A__        =			{
							    "image": init_image,
							    "image_embeds": image_embeds,
							    "negative_image_embeds": negative_image_embeds,
							    "hint": hint,
							    "generator": generator,
							    "height": 64,
							    "width": 64,
							    "num_inference_steps": 10,
							    "guidance_scale": 7.0,
							    "strength": 0.2,
							    "output_type": "np",
							}
							return inputs


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






							A__        =			"cpu"

							A__        =			self.get_dummy_components()

							A__        =			self.pipeline_class(**_lowerCamelCase       )
							A__        =			pipe.to(_lowerCamelCase       )

							pipe.set_progress_bar_config(disable=_lowerCamelCase       )

							A__        =			pipe(**self.get_dummy_inputs(_lowerCamelCase       )       )
							A__        =			output.images

							A__        =			pipe(
							    **self.get_dummy_inputs(_lowerCamelCase       )      ,      return_dict=_lowerCamelCase      ,      )[0]

							A__        =			image[0, -3:, -3:, -1]
							A__        =			image_from_tuple[0, -3:, -3:, -1]

							assert image.shape == (1, 64, 64, 3)

							A__        =			np.array(
							    [0.5498_5034, 0.5550_9365, 0.5256_1504, 0.557_0494, 0.559_3818, 0.526_3979, 0.5028_5643, 0.506_9846, 0.5119_6736]       )
							assert (
							    np.abs(image_slice.flatten() - expected_slice       ).max() < 1e-2
							), F' expected_slice {expected_slice}, but got {image_slice.flatten()}'
							assert (
							    np.abs(image_from_tuple_slice.flatten() - expected_slice       ).max() < 1e-2
							), F' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}'

@slow
@require_torch_gpu
class 					a__						(					unittest.TestCase			):
			"""simple docstring"""







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






							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()


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






							A__        =			load_numpy(
							    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
							    "/kandinskyv22/kandinskyv22_controlnet_img2img_robotcat_fp16.npy"       )

							A__        =			load_image(
							    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" "/kandinsky/cat.png"       )
							A__        =			init_image.resize((512, 512)       )

							A__        =			load_image(
							    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
							    "/kandinskyv22/hint_image_cat.png"       )
							A__        =			torch.from_numpy(np.array(_lowerCamelCase       )       ).float() / 255.0
							A__        =			hint.permute(2      ,      0      ,      1       ).unsqueeze(0       )

							A__        =			"A robot, 4k photo"

							A__        =			KandinskyVaaPriorEmbaEmbPipeline.from_pretrained(
							    "kandinsky-community/kandinsky-2-2-prior"      ,      torch_dtype=torch.floataa       )
							pipe_prior.to(_lowerCamelCase       )

							A__        =			KandinskyVaaControlnetImgaImgPipeline.from_pretrained(
							    "kandinsky-community/kandinsky-2-2-controlnet-depth"      ,      torch_dtype=torch.floataa       )
							A__        =			pipeline.to(_lowerCamelCase       )

							pipeline.set_progress_bar_config(disable=_lowerCamelCase       )

							A__        =			torch.Generator(device="cpu"       ).manual_seed(0       )

							A__    ,				A__        =			pipe_prior(
							    _lowerCamelCase      ,      image=_lowerCamelCase      ,      strength=0.85      ,      generator=_lowerCamelCase      ,      negative_prompt=""      ,      ).to_tuple()

							A__        =			pipeline(
							    image=_lowerCamelCase      ,      image_embeds=_lowerCamelCase      ,      negative_image_embeds=_lowerCamelCase      ,      hint=_lowerCamelCase      ,      generator=_lowerCamelCase      ,      num_inference_steps=100      ,      height=512      ,      width=512      ,      strength=0.5      ,      output_type="np"      ,      )

							A__        =			output.images[0]

							assert image.shape == (512, 512, 3)

							assert_mean_pixel_difference(_lowerCamelCase      ,      _lowerCamelCase       )


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

