

"""simple docstring"""


import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLImgaImgPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()





class     snake_case	(				__snake_case,							__snake_case,							unittest.TestCase  ):
				SCREAMING_SNAKE_CASE_   :      Union[str, Any]         =  StableDiffusionXLImgaImgPipeline
				SCREAMING_SNAKE_CASE_   :      Dict         =  TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""height""", """width"""}
				SCREAMING_SNAKE_CASE_   :      Optional[int]         =  PipelineTesterMixin.required_optional_params - {"""latents"""}
				SCREAMING_SNAKE_CASE_   :      List[str]         =  TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
				SCREAMING_SNAKE_CASE_   :      Optional[int]         =  IMAGE_TO_IMAGE_IMAGE_PARAMS
				SCREAMING_SNAKE_CASE_   :      Tuple         =  IMAGE_TO_IMAGE_IMAGE_PARAMS

				def 							lowercase_     (	self							:				Union[str, Any])->   List[Any]:



						'''simple docstring'''


						torch.manual_seed(0)
						__lowerCAmelCase:       Union[str, Any]          =			UNetaDConditionModel(
						    block_out_channels=(3_2, 6_4)     ,  layers_per_block=2     ,  sample_size=3_2     ,  in_channels=4     ,  out_channels=4     ,  down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")     ,  up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")     ,  attention_head_dim=(2, 4)     ,  use_linear_projection=UpperCamelCase__     ,  addition_embed_type="text_time"     ,  addition_time_embed_dim=8     ,  transformer_layers_per_block=(1, 2)     ,  projection_class_embeddings_input_dim=8_0     ,  cross_attention_dim=6_4     ,  )
						__lowerCAmelCase:       List[str]          =			EulerDiscreteScheduler(
						    beta_start=0.00085     ,  beta_end=0.012     ,  steps_offset=1     ,  beta_schedule="scaled_linear"     ,  timestep_spacing="leading"     ,  )
						torch.manual_seed(0)
						__lowerCAmelCase:       Union[str, Any]          =			AutoencoderKL(
						    block_out_channels=[3_2, 6_4]     ,  in_channels=3     ,  out_channels=3     ,  down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]     ,  up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]     ,  latent_channels=4     ,  sample_size=1_2_8     ,  )
						torch.manual_seed(0)
						__lowerCAmelCase:       Union[str, Any]          =			CLIPTextConfig(
						    bos_token_id=0     ,  eos_token_id=2     ,  hidden_size=3_2     ,  intermediate_size=3_7     ,  layer_norm_eps=1e-05     ,  num_attention_heads=4     ,  num_hidden_layers=5     ,  pad_token_id=1     ,  vocab_size=1_0_0_0     ,  hidden_act="gelu"     ,  projection_dim=3_2     ,  )
						__lowerCAmelCase:       Optional[Any]          =			CLIPTextModel(UpperCamelCase__)
						__lowerCAmelCase:       Optional[Any]          =			CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"     ,  local_files_only=UpperCamelCase__)

						__lowerCAmelCase:       Tuple          =			CLIPTextModelWithProjection(UpperCamelCase__)
						__lowerCAmelCase:       Tuple          =			CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"     ,  local_files_only=UpperCamelCase__)

						__lowerCAmelCase:       List[str]          =			{
						    "unet": unet,
						    "scheduler": scheduler,
						    "vae": vae,
						    "text_encoder": text_encoder,
						    "tokenizer": tokenizer,
						    "text_encoder_2": text_encoder_a,
						    "tokenizer_2": tokenizer_a,
						    # "safety_checker": None,
						    # "feature_extractor": None,
						}
						return components

				def 							lowercase_     (	self							:				Union[str, Any]     ,  UpperCamelCase__							:				Optional[Any]     ,  UpperCamelCase__							:				Union[str, Any]=0)->   Any:



						'''simple docstring'''


						__lowerCAmelCase:       Union[str, Any]          =			floats_tensor((1, 3, 3_2, 3_2)     ,  rng=random.Random(UpperCamelCase__)).to(UpperCamelCase__)
						__lowerCAmelCase:       List[str]          =			image / 2 + 0.5
						if str(UpperCamelCase__).startswith("mps"):
								__lowerCAmelCase:       Optional[Any]          =			torch.manual_seed(UpperCamelCase__)
						else:
								__lowerCAmelCase:       Optional[int]          =			torch.Generator(device=UpperCamelCase__).manual_seed(UpperCamelCase__)
						__lowerCAmelCase:       List[Any]          =			{
						    "prompt": "A painting of a squirrel eating a burger",
						    "image": image,
						    "generator": generator,
						    "num_inference_steps": 2,
						    "guidance_scale": 5.0,
						    "output_type": "numpy",
						    "strength": 0.75,
						}
						return inputs

				def 							lowercase_     (	self							:				Dict)->   Union[str, Any]:



						'''simple docstring'''


						__lowerCAmelCase:       Union[str, Any]          =			"cpu"  # ensure determinism for the device-dependent torch.Generator
						__lowerCAmelCase:       int          =			self.get_dummy_components()
						__lowerCAmelCase:       Optional[int]          =			StableDiffusionXLImgaImgPipeline(**UpperCamelCase__)
						__lowerCAmelCase:       int          =			sd_pipe.to(UpperCamelCase__)
						sd_pipe.set_progress_bar_config(disable=UpperCamelCase__)

						__lowerCAmelCase:       str          =			self.get_dummy_inputs(UpperCamelCase__)
						__lowerCAmelCase:       Union[str, Any]          =			sd_pipe(**UpperCamelCase__).images
						__lowerCAmelCase:       Tuple          =			image[0, -3:, -3:, -1]

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

						__lowerCAmelCase:       Any          =			np.array([0.4656, 0.4840, 0.4439, 0.6698, 0.5574, 0.4524, 0.5799, 0.5943, 0.5165])

						assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2

				def 							lowercase_     (	self							:				Tuple)->   List[str]:



						'''simple docstring'''


						super().test_attention_slicing_forward_pass(expected_max_diff=3e-3)

				def 							lowercase_     (	self							:				List[Any])->   List[str]:



						'''simple docstring'''


						super().test_inference_batch_single_identical(expected_max_diff=3e-3)

				def 							lowercase_     (	self							:				Optional[int])->   Any:



						'''simple docstring'''


						pass




				def 							lowercase_     (	self							:				Dict)->   Optional[int]:



						'''simple docstring'''


						__lowerCAmelCase:       List[str]          =			self.get_dummy_components()
						__lowerCAmelCase:       Optional[int]          =			StableDiffusionXLImgaImgPipeline(**UpperCamelCase__)
						__lowerCAmelCase:       Union[str, Any]          =			sd_pipe.to(UpperCamelCase__)
						__lowerCAmelCase:       Tuple          =			sd_pipe.to(UpperCamelCase__)
						sd_pipe.set_progress_bar_config(disable=UpperCamelCase__)

						# forward without prompt embeds
						__lowerCAmelCase:       Tuple          =			self.get_dummy_inputs(UpperCamelCase__)
						__lowerCAmelCase:       Any          =			3 * ["this is a negative prompt"]
						__lowerCAmelCase:       Tuple          =			negative_prompt
						__lowerCAmelCase:       Any          =			3 * [inputs["prompt"]]

						__lowerCAmelCase:       Optional[Any]          =			sd_pipe(**UpperCamelCase__)
						__lowerCAmelCase:       Union[str, Any]          =			output.images[0, -3:, -3:, -1]

						# forward with prompt embeds
						__lowerCAmelCase:       str          =			self.get_dummy_inputs(UpperCamelCase__)
						__lowerCAmelCase:       Tuple          =			3 * ["this is a negative prompt"]
						__lowerCAmelCase:       str          =			3 * [inputs.pop("prompt")]

						(
						    (
						    __lowerCAmelCase
						)      , (
						    __lowerCAmelCase
						)      , (
						    __lowerCAmelCase
						)      , (
						    __lowerCAmelCase
						)      , 
						):       Optional[Any]          =			sd_pipe.encode_prompt(UpperCamelCase__     ,  negative_prompt=UpperCamelCase__)

						__lowerCAmelCase:       Union[str, Any]          =			sd_pipe(
						    **UpperCamelCase__     ,  prompt_embeds=UpperCamelCase__     ,  negative_prompt_embeds=UpperCamelCase__     ,  pooled_prompt_embeds=UpperCamelCase__     ,  negative_pooled_prompt_embeds=UpperCamelCase__     ,  )
						__lowerCAmelCase:       Optional[int]          =			output.images[0, -3:, -3:, -1]

						# make sure that it's equal
						assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()).max() < 1e-4





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

				def 							lowercase_     (	self							:				Optional[int])->   Union[str, Any]:



						'''simple docstring'''


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

				def 							lowercase_     (	self							:				Optional[Any]     ,  UpperCamelCase__							:				Optional[int]     ,  UpperCamelCase__							:				List[str]="cpu"     ,  UpperCamelCase__							:				str=torch.floataa     ,  UpperCamelCase__							:				Any=0)->   Union[str, Any]:



						'''simple docstring'''


						__lowerCAmelCase:       Dict          =			torch.Generator(device=UpperCamelCase__).manual_seed(UpperCamelCase__)
						__lowerCAmelCase:       List[Any]          =			np.random.RandomState(UpperCamelCase__).standard_normal((1, 4, 6_4, 6_4))
						__lowerCAmelCase:       int          =			torch.from_numpy(UpperCamelCase__).to(device=UpperCamelCase__     ,  dtype=UpperCamelCase__)
						__lowerCAmelCase:       List[str]          =			{
						    "prompt": "a photograph of an astronaut riding a horse",
						    "latents": latents,
						    "generator": generator,
						    "num_inference_steps": 3,
						    "guidance_scale": 7.5,
						    "output_type": "numpy",
						}
						return inputs




				def 							lowercase_     (	self							:				str)->   List[str]:



						'''simple docstring'''


						__lowerCAmelCase:       List[str]          =			DiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-2-base")
						pipe.to(UpperCamelCase__)
						pipe.set_progress_bar_config(disable=UpperCamelCase__)

						__lowerCAmelCase:       Tuple          =			self.get_inputs(UpperCamelCase__)
						__lowerCAmelCase:       str          =			pipe(**UpperCamelCase__).images
						__lowerCAmelCase:       Tuple          =			image[0, -3:, -3:, -1].flatten()

						assert image.shape == (1, 5_1_2, 5_1_2, 3)
						__lowerCAmelCase:       Dict          =			np.array([0.49493, 0.47896, 0.40798, 0.54214, 0.53212, 0.48202, 0.47656, 0.46329, 0.48506])
						assert np.abs(image_slice - expected_slice).max() < 7e-3





"""simple docstring"""


def     a__    (    __SCREAMING_SNAKE_CASE )	->	int:
		__lowerCAmelCase:       Optional[Any]          =			1
		for i in range(1					, num + 1 ):
				fact *= i
		return fact






def     a__    (    __SCREAMING_SNAKE_CASE )	->	int:
		__lowerCAmelCase:       List[str]          =			0
		while number > 0:
				__lowerCAmelCase:       Any          =			number % 1_0
				sum_of_digits += last_digit
				__lowerCAmelCase:       List[Any]          =			number // 1_0  # Removing the last_digit from the given number
		return sum_of_digits






def     a__    (    __SCREAMING_SNAKE_CASE = 1_0_0 )	->	int:
		__lowerCAmelCase:       Tuple          =			factorial(__SCREAMING_SNAKE_CASE )
		__lowerCAmelCase:       Optional[int]          =			split_and_add(__SCREAMING_SNAKE_CASE )
		return result


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


