"""simple docstring"""







import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPImageProcessor, CLIPVisionConfig, CLIPVisionModelWithProjection

from diffusers import (
    AutoencoderKL,
    DPMSolverMultistepScheduler,
    PNDMScheduler,
    StableDiffusionImageVariationPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, load_image, load_numpy, nightly, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import IMAGE_VARIATION_BATCH_PARAMS, IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()

class 						UpperCamelCase     (       lowercase ,      lowercase ,      lowercase ,      unittest.TestCase		):
				UpperCAmelCase							: Any       =						StableDiffusionImageVariationPipeline
				UpperCAmelCase							: Dict       =						IMAGE_VARIATION_PARAMS
				UpperCAmelCase							: Any       =						IMAGE_VARIATION_BATCH_PARAMS
				UpperCAmelCase							: int       =						frozenset([]		)
				# TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
				UpperCAmelCase							: str       =						frozenset([]		)



				def    _lowercase	(self							: Any)       ->      Tuple:
					torch.manual_seed(0)
					__snake_case     :				Any 						=					UNetaDConditionModel(
					    block_out_channels=(32, 64)      ,    layers_per_block=2      ,    sample_size=32      ,    in_channels=4      ,    out_channels=4      ,    down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')      ,    up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')      ,    cross_attention_dim=32      ,    )
					__snake_case     :				Optional[Any] 						=					PNDMScheduler(skip_prk_steps=_A)
					torch.manual_seed(0)
					__snake_case     :				List[str] 						=					AutoencoderKL(
					    block_out_channels=[32, 64]      ,    in_channels=3      ,    out_channels=3      ,    down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']      ,    up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']      ,    latent_channels=4      ,    )
					torch.manual_seed(0)
					__snake_case     :				Dict 						=					CLIPVisionConfig(
					    hidden_size=32      ,    projection_dim=32      ,    intermediate_size=37      ,    layer_norm_eps=1E-05      ,    num_attention_heads=4      ,    num_hidden_layers=5      ,    image_size=32      ,    patch_size=4      ,    )
					__snake_case     :				Optional[int] 						=					CLIPVisionModelWithProjection(_A)
					__snake_case     :				Optional[Any] 						=					CLIPImageProcessor(crop_size=32      ,    size=32)

					__snake_case     :				Union[str, Any] 						=					{
					    'unet': unet,
					    'scheduler': scheduler,
					    'vae': vae,
					    'image_encoder': image_encoder,
					    'feature_extractor': feature_extractor,
					    'safety_checker': None,
					}
					return components



				def    _lowercase	(self							: Optional[int]      ,    _A							: Dict      ,    _A							: Union[str, Any]=0)       ->      int:
					__snake_case     :				List[str] 						=					floats_tensor((1, 3, 32, 32)      ,    rng=random.Random(_A))
					__snake_case     :				Optional[int] 						=					image.cpu().permute(0      ,    2      ,    3      ,    1)[0]
					__snake_case     :				Any 						=					Image.fromarray(np.uinta(_A)).convert('RGB').resize((32, 32))
					if str(_A).startswith('mps'):
						__snake_case     :				int 						=					torch.manual_seed(_A)
					else:
						__snake_case     :				List[str] 						=					torch.Generator(device=_A).manual_seed(_A)
					__snake_case     :				str 						=					{
					    'image': image,
					    'generator': generator,
					    'num_inference_steps': 2,
					    'guidance_scale': 6.0,
					    'output_type': 'numpy',
					}
					return inputs



				def    _lowercase	(self							: Dict)       ->      List[str]:
					__snake_case     :				str 						=					'cpu'  # ensure determinism for the device-dependent torch.Generator
					__snake_case     :				str 						=					self.get_dummy_components()
					__snake_case     :				Any 						=					StableDiffusionImageVariationPipeline(**_A)
					__snake_case     :				Optional[Any] 						=					sd_pipe.to(_A)
					sd_pipe.set_progress_bar_config(disable=_A)

					__snake_case     :				Optional[int] 						=					self.get_dummy_inputs(_A)
					__snake_case     :				Dict 						=					sd_pipe(**_A).images
					__snake_case     :				Dict 						=					image[0, -3:, -3:, -1]

					assert image.shape == (1, 64, 64, 3)
					__snake_case     :				List[str] 						=					np.array([0.5_239, 0.5_723, 0.4_796, 0.5_049, 0.5_550, 0.4_685, 0.5_329, 0.4_891, 0.4_921])

					assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3



				def    _lowercase	(self							: List[str])       ->      int:
					__snake_case     :				int 						=					'cpu'  # ensure determinism for the device-dependent torch.Generator
					__snake_case     :				int 						=					self.get_dummy_components()
					__snake_case     :				Dict 						=					StableDiffusionImageVariationPipeline(**_A)
					__snake_case     :				Tuple 						=					sd_pipe.to(_A)
					sd_pipe.set_progress_bar_config(disable=_A)

					__snake_case     :				List[str] 						=					self.get_dummy_inputs(_A)
					__snake_case     :				List[str] 						=					2 * [inputs['image']]
					__snake_case     :				List[Any] 						=					sd_pipe(**_A)

					__snake_case     :				int 						=					output.images

					__snake_case     :				Tuple 						=					image[-1, -3:, -3:, -1]

					assert image.shape == (2, 64, 64, 3)
					__snake_case     :				List[Any] 						=					np.array([0.6_892, 0.5_637, 0.5_836, 0.5_771, 0.6_254, 0.6_409, 0.5_580, 0.5_569, 0.5_289])

					assert np.abs(image_slice.flatten() - expected_slice).max() < 1E-3






				def    _lowercase	(self							: Union[str, Any])       ->      Dict:
					super().test_inference_batch_single_identical(expected_max_diff=3E-3)







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



				def    _lowercase	(self							: Dict)       ->      Dict:
					super().tearDown()
					gc.collect()
					torch.cuda.empty_cache()



				def    _lowercase	(self							: Any      ,    _A							: Union[str, Any]      ,    _A							: Tuple="cpu"      ,    _A							: int=torch.floataa      ,    _A							: int=0)       ->      List[str]:
					__snake_case     :				List[Any] 						=					torch.Generator(device=_A).manual_seed(_A)
					__snake_case     :				Union[str, Any] 						=					load_image(
					    'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
					    '/stable_diffusion_imgvar/input_image_vermeer.png')
					__snake_case     :				int 						=					np.random.RandomState(_A).standard_normal((1, 4, 64, 64))
					__snake_case     :				Any 						=					torch.from_numpy(_A).to(device=_A      ,    dtype=_A)
					__snake_case     :				str 						=					{
					    'image': init_image,
					    'latents': latents,
					    'generator': generator,
					    'num_inference_steps': 3,
					    'guidance_scale': 7.5,
					    'output_type': 'numpy',
					}
					return inputs



				def    _lowercase	(self							: Union[str, Any])       ->      Union[str, Any]:
					__snake_case     :				int 						=					StableDiffusionImageVariationPipeline.from_pretrained(
					    'lambdalabs/sd-image-variations-diffusers'      ,    safety_checker=_A)
					__snake_case     :				Optional[Any] 						=					sd_pipe.to(_A)
					sd_pipe.set_progress_bar_config(disable=_A)

					__snake_case     :				Any 						=					self.get_inputs(_A)
					__snake_case     :				str 						=					sd_pipe(**_A).images
					__snake_case     :				List[str] 						=					image[0, -3:, -3:, -1].flatten()

					assert image.shape == (1, 5_12, 5_12, 3)
					__snake_case     :				Union[str, Any] 						=					np.array([0.84_491, 0.90_789, 0.75_708, 0.78_734, 0.83_485, 0.70_099, 0.66_938, 0.68_727, 0.61_379])
					assert np.abs(image_slice - expected_slice).max() < 6E-3



				def    _lowercase	(self							: int)       ->      Tuple:
					__snake_case     :				Optional[int] 						=					0

					def callback_fn(_A							: int      ,    _A							: int      ,    _A							: torch.FloatTensor) -> None:
						__snake_case     :				Dict 						=					True
						nonlocal number_of_steps
						number_of_steps += 1
						if step == 1:
							__snake_case     :				Union[str, Any] 						=					latents.detach().cpu().numpy()
							assert latents.shape == (1, 4, 64, 64)
							__snake_case     :				Tuple 						=					latents[0, -3:, -3:, -1]
							__snake_case     :				List[Any] 						=					np.array(
							    [-0.1_621, 0.2_837, -0.7_979, -0.1_221, -1.3_057, 0.7_681, -2.1_191, 0.0_464, 1.6_309])

							assert np.abs(latents_slice.flatten() - expected_slice).max() < 5E-2
						elif step == 2:
							__snake_case     :				Any 						=					latents.detach().cpu().numpy()
							assert latents.shape == (1, 4, 64, 64)
							__snake_case     :				Union[str, Any] 						=					latents[0, -3:, -3:, -1]
							__snake_case     :				Union[str, Any] 						=					np.array([0.6_299, 1.7_500, 1.1_992, -2.1_582, -1.8_994, 0.7_334, -0.7_090, 1.0_137, 1.5_273])

							assert np.abs(latents_slice.flatten() - expected_slice).max() < 5E-2

					__snake_case     :				Tuple 						=					False

					__snake_case     :				Any 						=					StableDiffusionImageVariationPipeline.from_pretrained(
					    'fusing/sd-image-variations-diffusers'      ,    safety_checker=_A      ,    torch_dtype=torch.floataa      ,    )
					pipe.to(_A)
					pipe.set_progress_bar_config(disable=_A)
					pipe.enable_attention_slicing()

					__snake_case     :				Optional[int] 						=					self.get_inputs(_A      ,    dtype=torch.floataa)
					pipe(**_A      ,    callback=_A      ,    callback_steps=1)
					assert callback_fn.has_been_called
					assert number_of_steps == inputs["num_inference_steps"]






				def    _lowercase	(self							: Optional[Any])       ->      Tuple:
					torch.cuda.empty_cache()
					torch.cuda.reset_max_memory_allocated()
					torch.cuda.reset_peak_memory_stats()

					__snake_case     :				List[Any] 						=					'fusing/sd-image-variations-diffusers'
					__snake_case     :				Tuple 						=					StableDiffusionImageVariationPipeline.from_pretrained(
					    _A      ,    safety_checker=_A      ,    torch_dtype=torch.floataa)
					__snake_case     :				Tuple 						=					pipe.to(_A)
					pipe.set_progress_bar_config(disable=_A)
					pipe.enable_attention_slicing(1)
					pipe.enable_sequential_cpu_offload()

					__snake_case     :				int 						=					self.get_inputs(_A      ,    dtype=torch.floataa)
					__snake_case     :				int 						=					pipe(**_A)

					__snake_case     :				Dict 						=					torch.cuda.max_memory_allocated()
					# make sure that less than 2.6 GB is allocated
					assert mem_bytes < 2.6 * 10**9







@nightly
@require_torch_gpu
class 						UpperCamelCase     (       unittest.TestCase		):



				def    _lowercase	(self							: str)       ->      int:
					super().tearDown()
					gc.collect()
					torch.cuda.empty_cache()



				def    _lowercase	(self							: Optional[int]      ,    _A							: str      ,    _A							: Optional[int]="cpu"      ,    _A							: Dict=torch.floataa      ,    _A							: List[Any]=0)       ->      int:
					__snake_case     :				str 						=					torch.Generator(device=_A).manual_seed(_A)
					__snake_case     :				List[str] 						=					load_image(
					    'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
					    '/stable_diffusion_imgvar/input_image_vermeer.png')
					__snake_case     :				Optional[int] 						=					np.random.RandomState(_A).standard_normal((1, 4, 64, 64))
					__snake_case     :				Dict 						=					torch.from_numpy(_A).to(device=_A      ,    dtype=_A)
					__snake_case     :				List[str] 						=					{
					    'image': init_image,
					    'latents': latents,
					    'generator': generator,
					    'num_inference_steps': 50,
					    'guidance_scale': 7.5,
					    'output_type': 'numpy',
					}
					return inputs



				def    _lowercase	(self							: List[Any])       ->      Dict:
					__snake_case     :				List[Any] 						=					StableDiffusionImageVariationPipeline.from_pretrained('fusing/sd-image-variations-diffusers')
					sd_pipe.to(_A)
					sd_pipe.set_progress_bar_config(disable=_A)

					__snake_case     :				List[Any] 						=					self.get_inputs(_A)
					__snake_case     :				str 						=					sd_pipe(**_A).images[0]

					__snake_case     :				Optional[int] 						=					load_numpy(
					    'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
					    '/stable_diffusion_imgvar/lambdalabs_variations_pndm.npy')
					__snake_case     :				Dict 						=					np.abs(expected_image - image).max()
					assert max_diff < 1E-3






				def    _lowercase	(self							: str)       ->      Tuple:
					__snake_case     :				int 						=					StableDiffusionImageVariationPipeline.from_pretrained('fusing/sd-image-variations-diffusers')
					__snake_case     :				Union[str, Any] 						=					DPMSolverMultistepScheduler.from_config(sd_pipe.scheduler.config)
					sd_pipe.to(_A)
					sd_pipe.set_progress_bar_config(disable=_A)

					__snake_case     :				Tuple 						=					self.get_inputs(_A)
					__snake_case     :				Optional[Any] 						=					25
					__snake_case     :				Optional[Any] 						=					sd_pipe(**_A).images[0]

					__snake_case     :				List[str] 						=					load_numpy(
					    'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
					    '/stable_diffusion_imgvar/lambdalabs_variations_dpm_multi.npy')
					__snake_case     :				Tuple 						=					np.abs(expected_image - image).max()
					assert max_diff < 1E-3






"""simple docstring"""







def     __UpperCAmelCase							(       UpperCAmelCase_       :							int = 1_00    )				->     int:

	'''simple docstring'''





	__snake_case     :				Any 						=					1
	__snake_case     :				Tuple 						=					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())))





