


"""simple docstring"""






import inspect
from typing import Optional, Union

import numpy as np
import PIL
import torch
from torch.nn import functional as F
from torchvision import transforms
from transformers import CLIPFeatureExtractor, CLIPModel, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    DPMSolverMultistepScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput
from diffusers.utils import (
    PIL_INTERPOLATION,
    randn_tensor,
)


def __lowercase     (      lowerCamelCase_  :      List[str]						,					lowerCamelCase_  :      int						,					lowerCamelCase_  :      Optional[Any]  ):
				if isinstance(lowerCamelCase_						,					torch.Tensor  ):
								return image
				elif isinstance(lowerCamelCase_						,					PIL.Image.Image  ):
								SCREAMING_SNAKE_CASE__     							=				[image]

				if isinstance(image[0]						,					PIL.Image.Image  ):
								SCREAMING_SNAKE_CASE__     							=				[np.array(i.resize((w, h)						,					resample=PIL_INTERPOLATION["lanczos"]  )  )[None, :] for i in image]
								SCREAMING_SNAKE_CASE__     							=				np.concatenate(lowerCamelCase_						,					axis=0  )
								SCREAMING_SNAKE_CASE__     							=				np.array(lowerCamelCase_  ).astype(np.floataa  ) / 255.0
								SCREAMING_SNAKE_CASE__     							=				image.transpose(0						,					3						,					1						,					2  )
								SCREAMING_SNAKE_CASE__     							=				2.0 * image - 1.0
								SCREAMING_SNAKE_CASE__     							=				torch.from_numpy(lowerCamelCase_  )
				elif isinstance(image[0]						,					torch.Tensor  ):
								SCREAMING_SNAKE_CASE__     							=				torch.cat(lowerCamelCase_						,					dim=0  )
				return image


def __lowercase     (      lowerCamelCase_  :      List[str]						,					lowerCamelCase_  :      Optional[int]						,					lowerCamelCase_  :      Optional[int]						,					lowerCamelCase_  :      Dict=0.9995  ):
				if not isinstance(lowerCamelCase_						,					np.ndarray  ):
								SCREAMING_SNAKE_CASE__     							=				True
								SCREAMING_SNAKE_CASE__     							=				va.device
								SCREAMING_SNAKE_CASE__     							=				va.cpu().numpy()
								SCREAMING_SNAKE_CASE__     							=				va.cpu().numpy()

				SCREAMING_SNAKE_CASE__     							=				np.sum(va * va / (np.linalg.norm(lowerCamelCase_  ) * np.linalg.norm(lowerCamelCase_  ))  )
				if np.abs(lowerCamelCase_  ) > DOT_THRESHOLD:
								SCREAMING_SNAKE_CASE__     							=				(1 - t) * va + t * va
				else:
								SCREAMING_SNAKE_CASE__     							=				np.arccos(lowerCamelCase_  )
								SCREAMING_SNAKE_CASE__     							=				np.sin(lowerCamelCase_  )
								SCREAMING_SNAKE_CASE__     							=				theta_a * t
								SCREAMING_SNAKE_CASE__     							=				np.sin(lowerCamelCase_  )
								SCREAMING_SNAKE_CASE__     							=				np.sin(theta_a - theta_t  ) / sin_theta_a
								SCREAMING_SNAKE_CASE__     							=				sin_theta_t / sin_theta_a
								SCREAMING_SNAKE_CASE__     							=				sa * va + sa * va

				if inputs_are_torch:
								SCREAMING_SNAKE_CASE__     							=				torch.from_numpy(lowerCamelCase_  ).to(lowerCamelCase_  )

				return va


def __lowercase     (      lowerCamelCase_  :      List[str]						,					lowerCamelCase_  :      int  ):
				SCREAMING_SNAKE_CASE__     							=				F.normalize(lowerCamelCase_						,					dim=-1  )
				SCREAMING_SNAKE_CASE__     							=				F.normalize(lowerCamelCase_						,					dim=-1  )
				return (x - y).norm(dim=-1  ).div(2  ).arcsin().pow(2  ).mul(2  )


def __lowercase     (      lowerCamelCase_  :      List[str]						,					lowerCamelCase_  :      Optional[int]  ):
				for param in model.parameters():
								SCREAMING_SNAKE_CASE__     							=				value


class 			lowerCamelCase_		(			lowercase   ):





				"""simple docstring"""







				def __init__(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__=None       ,		UpperCAmelCase__=None       ,		UpperCAmelCase__=None       ,		):
								super().__init__()
								self.register_modules(
								    vae=UpperCAmelCase__       ,		text_encoder=UpperCAmelCase__       ,		clip_model=UpperCAmelCase__       ,		tokenizer=UpperCAmelCase__       ,		unet=UpperCAmelCase__       ,		scheduler=UpperCAmelCase__       ,		feature_extractor=UpperCAmelCase__       ,		coca_model=UpperCAmelCase__       ,		coca_tokenizer=UpperCAmelCase__       ,		coca_transform=UpperCAmelCase__       ,		)
								SCREAMING_SNAKE_CASE__     							=				(
								    feature_extractor.size
								    if isinstance(feature_extractor.size       ,		UpperCAmelCase__     )
								    else feature_extractor.size["shortest_edge"]
								)
								SCREAMING_SNAKE_CASE__     							=				transforms.Normalize(mean=feature_extractor.image_mean       ,		std=feature_extractor.image_std     )
								set_requires_grad(self.text_encoder       ,		UpperCAmelCase__     )
								set_requires_grad(self.clip_model       ,		UpperCAmelCase__     )



				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__ = "auto"     ):
								if slice_size == "auto":
												# half the attention head size is usually a good trade-off between
												# speed and memory
												SCREAMING_SNAKE_CASE__     							=				self.unet.config.attention_head_dim // 2
								self.unet.set_attention_slice(UpperCAmelCase__     )



				def   lowerCAmelCase__		(						self     ):
								self.enable_attention_slicing(UpperCAmelCase__     )



				def   lowerCAmelCase__		(						self     ):
								set_requires_grad(self.vae       ,		UpperCAmelCase__     )



				def   lowerCAmelCase__		(						self     ):
								set_requires_grad(self.vae       ,		UpperCAmelCase__     )



				def   lowerCAmelCase__		(						self     ):
								set_requires_grad(self.unet       ,		UpperCAmelCase__     )



				def   lowerCAmelCase__		(						self     ):
								set_requires_grad(self.unet       ,		UpperCAmelCase__     )



				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__     ):
								# get the original timestep using init_timestep
								SCREAMING_SNAKE_CASE__     							=				min(int(num_inference_steps * strength     )       ,		UpperCAmelCase__     )

								SCREAMING_SNAKE_CASE__     							=				max(num_inference_steps - init_timestep       ,		0     )
								SCREAMING_SNAKE_CASE__     							=				self.scheduler.timesteps[t_start:]

								return timesteps, num_inference_steps - t_start



				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__=None     ):
								if not isinstance(UpperCAmelCase__       ,		torch.Tensor     ):
												raise ValueError(f'''`image` has to be of type `torch.Tensor` but is {type(UpperCAmelCase__     )}'''     )

								SCREAMING_SNAKE_CASE__     							=				image.to(device=UpperCAmelCase__       ,		dtype=UpperCAmelCase__     )

								if isinstance(UpperCAmelCase__       ,		UpperCAmelCase__     ):
												SCREAMING_SNAKE_CASE__     							=				[
												    self.vae.encode(image[i : i + 1]     ).latent_dist.sample(generator[i]     ) for i in range(UpperCAmelCase__     )
												]
												SCREAMING_SNAKE_CASE__     							=				torch.cat(UpperCAmelCase__       ,		dim=0     )
								else:
												SCREAMING_SNAKE_CASE__     							=				self.vae.encode(UpperCAmelCase__     ).latent_dist.sample(UpperCAmelCase__     )

								# Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
								SCREAMING_SNAKE_CASE__     							=				0.18_215 * init_latents
								SCREAMING_SNAKE_CASE__     							=				init_latents.repeat_interleave(UpperCAmelCase__       ,		dim=0     )

								SCREAMING_SNAKE_CASE__     							=				randn_tensor(init_latents.shape       ,		generator=UpperCAmelCase__       ,		device=UpperCAmelCase__       ,		dtype=UpperCAmelCase__     )

								# get latents
								SCREAMING_SNAKE_CASE__     							=				self.scheduler.add_noise(UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				init_latents

								return latents



				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__     ):
								SCREAMING_SNAKE_CASE__     							=				self.coca_transform(UpperCAmelCase__     ).unsqueeze(0     )
								with torch.no_grad(), torch.cuda.amp.autocast():
												SCREAMING_SNAKE_CASE__     							=				self.coca_model.generate(transformed_image.to(device=self.device       ,		dtype=self.coca_model.dtype     )     )
								SCREAMING_SNAKE_CASE__     							=				self.coca_tokenizer.decode(generated[0].cpu().numpy()     )
								return generated.split("<end_of_text>"     )[0].replace("<start_of_text>"       ,		""     ).rstrip(" .,"     )



				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__     ):
								SCREAMING_SNAKE_CASE__     							=				self.feature_extractor.preprocess(UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				torch.from_numpy(clip_image_input["pixel_values"][0]     ).unsqueeze(0     ).to(self.device     ).half()
								SCREAMING_SNAKE_CASE__     							=				self.clip_model.get_image_features(UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				image_embeddings_clip / image_embeddings_clip.norm(p=2       ,		dim=-1       ,		keepdim=UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				image_embeddings_clip.repeat_interleave(UpperCAmelCase__       ,		dim=0     )
								return image_embeddings_clip



				@torch.enable_grad()
				def   lowerCAmelCase__		(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		):
								SCREAMING_SNAKE_CASE__     							=				latents.detach().requires_grad_()

								SCREAMING_SNAKE_CASE__     							=				self.scheduler.scale_model_input(UpperCAmelCase__       ,		UpperCAmelCase__     )

								# predict the noise residual
								SCREAMING_SNAKE_CASE__     							=				self.unet(UpperCAmelCase__       ,		UpperCAmelCase__       ,		encoder_hidden_states=UpperCAmelCase__     ).sample

								if isinstance(self.scheduler       ,		(PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)     ):
												SCREAMING_SNAKE_CASE__     							=				self.scheduler.alphas_cumprod[timestep]
												SCREAMING_SNAKE_CASE__     							=				1 - alpha_prod_t
												# compute predicted original sample from predicted noise also called
												# "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
												SCREAMING_SNAKE_CASE__     							=				(latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5

												SCREAMING_SNAKE_CASE__     							=				torch.sqrt(UpperCAmelCase__     )
												SCREAMING_SNAKE_CASE__     							=				pred_original_sample * (fac) + latents * (1 - fac)
								elif isinstance(self.scheduler       ,		UpperCAmelCase__     ):
												SCREAMING_SNAKE_CASE__     							=				self.scheduler.sigmas[index]
												SCREAMING_SNAKE_CASE__     							=				latents - sigma * noise_pred
								else:
												raise ValueError(f'''scheduler type {type(self.scheduler     )} not supported'''     )

								# Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
								SCREAMING_SNAKE_CASE__     							=				1 / 0.18_215 * sample
								SCREAMING_SNAKE_CASE__     							=				self.vae.decode(UpperCAmelCase__     ).sample
								SCREAMING_SNAKE_CASE__     							=				(image / 2 + 0.5).clamp(0       ,		1     )

								SCREAMING_SNAKE_CASE__     							=				transforms.Resize(self.feature_extractor_size     )(UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				self.normalize(UpperCAmelCase__     ).to(latents.dtype     )

								SCREAMING_SNAKE_CASE__     							=				self.clip_model.get_image_features(UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				image_embeddings_clip / image_embeddings_clip.norm(p=2       ,		dim=-1       ,		keepdim=UpperCAmelCase__     )

								SCREAMING_SNAKE_CASE__     							=				spherical_dist_loss(UpperCAmelCase__       ,		UpperCAmelCase__     ).mean() * clip_guidance_scale

								SCREAMING_SNAKE_CASE__     							=				-torch.autograd.grad(UpperCAmelCase__       ,		UpperCAmelCase__     )[0]

								if isinstance(self.scheduler       ,		UpperCAmelCase__     ):
												SCREAMING_SNAKE_CASE__     							=				latents.detach() + grads * (sigma**2)
												SCREAMING_SNAKE_CASE__     							=				noise_pred_original
								else:
												SCREAMING_SNAKE_CASE__     							=				noise_pred_original - torch.sqrt(UpperCAmelCase__     ) * grads
								return noise_pred, latents






				@torch.no_grad()
				def __call__(						self       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__ = None       ,		UpperCAmelCase__ = None       ,		UpperCAmelCase__ = 512       ,		UpperCAmelCase__ = 512       ,		UpperCAmelCase__ = 0.6       ,		UpperCAmelCase__ = 50       ,		UpperCAmelCase__ = 7.5       ,		UpperCAmelCase__ = 1       ,		UpperCAmelCase__ = 0.0       ,		UpperCAmelCase__ = 100       ,		UpperCAmelCase__ = None       ,		UpperCAmelCase__ = "pil"       ,		UpperCAmelCase__ = True       ,		UpperCAmelCase__ = 0.8       ,		UpperCAmelCase__ = 0.1       ,		UpperCAmelCase__ = 0.1       ,		):
								if isinstance(UpperCAmelCase__       ,		UpperCAmelCase__     ) and len(UpperCAmelCase__     ) != batch_size:
												raise ValueError(f'''You have passed {batch_size} batch_size, but only {len(UpperCAmelCase__     )} generators.'''     )

								if height % 8 != 0 or width % 8 != 0:
												raise ValueError(f'''`height` and `width` have to be divisible by 8 but are {height} and {width}.'''     )

								if isinstance(UpperCAmelCase__       ,		torch.Generator     ) and batch_size > 1:
												SCREAMING_SNAKE_CASE__     							=				[generator] + [None] * (batch_size - 1)

								SCREAMING_SNAKE_CASE__     							=				[
								    ("model", self.coca_model is None),
								    ("tokenizer", self.coca_tokenizer is None),
								    ("transform", self.coca_transform is None),
								]
								SCREAMING_SNAKE_CASE__     							=				[x[0] for x in coca_is_none if x[1]]
								SCREAMING_SNAKE_CASE__     							=				", ".join(UpperCAmelCase__     )
								# generate prompts with coca model if prompt is None
								if content_prompt is None:
												if len(UpperCAmelCase__     ):
																raise ValueError(
																    f'''Content prompt is None and CoCa [{coca_is_none_str}] is None.'''
																    f'''Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.'''     )
												SCREAMING_SNAKE_CASE__     							=				self.get_image_description(UpperCAmelCase__     )
								if style_prompt is None:
												if len(UpperCAmelCase__     ):
																raise ValueError(
																    f'''Style prompt is None and CoCa [{coca_is_none_str}] is None.'''
																    f''' Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.'''     )
												SCREAMING_SNAKE_CASE__     							=				self.get_image_description(UpperCAmelCase__     )

								# get prompt text embeddings for content and style
								SCREAMING_SNAKE_CASE__     							=				self.tokenizer(
								    UpperCAmelCase__       ,		padding="max_length"       ,		max_length=self.tokenizer.model_max_length       ,		truncation=UpperCAmelCase__       ,		return_tensors="pt"       ,		)
								SCREAMING_SNAKE_CASE__     							=				self.text_encoder(content_text_input.input_ids.to(self.device     )     )[0]

								SCREAMING_SNAKE_CASE__     							=				self.tokenizer(
								    UpperCAmelCase__       ,		padding="max_length"       ,		max_length=self.tokenizer.model_max_length       ,		truncation=UpperCAmelCase__       ,		return_tensors="pt"       ,		)
								SCREAMING_SNAKE_CASE__     							=				self.text_encoder(style_text_input.input_ids.to(self.device     )     )[0]

								SCREAMING_SNAKE_CASE__     							=				slerp(UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__     )

								# duplicate text embeddings for each generation per prompt
								SCREAMING_SNAKE_CASE__     							=				text_embeddings.repeat_interleave(UpperCAmelCase__       ,		dim=0     )

								# set timesteps
								SCREAMING_SNAKE_CASE__     							=				"offset" in set(inspect.signature(self.scheduler.set_timesteps     ).parameters.keys()     )
								SCREAMING_SNAKE_CASE__     							=				{}
								if accepts_offset:
												SCREAMING_SNAKE_CASE__     							=				1

								self.scheduler.set_timesteps(UpperCAmelCase__       ,		**UpperCAmelCase__     )
								# Some schedulers like PNDM have timesteps as arrays
								# It's more optimized to move all timesteps to correct device beforehand
								self.scheduler.timesteps.to(self.device     )

								SCREAMING_SNAKE_CASE__							,      SCREAMING_SNAKE_CASE__     							=				self.get_timesteps(UpperCAmelCase__       ,		UpperCAmelCase__       ,		self.device     )
								SCREAMING_SNAKE_CASE__     							=				timesteps[:1].repeat(UpperCAmelCase__     )

								# Preprocess image
								SCREAMING_SNAKE_CASE__     							=				preprocess(UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				self.prepare_latents(
								    UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		text_embeddings.dtype       ,		self.device       ,		UpperCAmelCase__     )

								SCREAMING_SNAKE_CASE__     							=				preprocess(UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__     )
								SCREAMING_SNAKE_CASE__     							=				self.prepare_latents(
								    UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		text_embeddings.dtype       ,		self.device       ,		UpperCAmelCase__     )

								SCREAMING_SNAKE_CASE__     							=				slerp(UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__     )

								if clip_guidance_scale > 0:
												SCREAMING_SNAKE_CASE__     							=				self.get_clip_image_embeddings(UpperCAmelCase__       ,		UpperCAmelCase__     )
												SCREAMING_SNAKE_CASE__     							=				self.get_clip_image_embeddings(UpperCAmelCase__       ,		UpperCAmelCase__     )
												SCREAMING_SNAKE_CASE__     							=				slerp(
												    UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__     )

								# here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
								# of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
								# corresponds to doing no classifier free guidance.
								SCREAMING_SNAKE_CASE__     							=				guidance_scale > 1.0
								# get unconditional embeddings for classifier free guidance
								if do_classifier_free_guidance:
												SCREAMING_SNAKE_CASE__     							=				content_text_input.input_ids.shape[-1]
												SCREAMING_SNAKE_CASE__     							=				self.tokenizer([""]       ,		padding="max_length"       ,		max_length=UpperCAmelCase__       ,		return_tensors="pt"     )
												SCREAMING_SNAKE_CASE__     							=				self.text_encoder(uncond_input.input_ids.to(self.device     )     )[0]
												# duplicate unconditional embeddings for each generation per prompt
												SCREAMING_SNAKE_CASE__     							=				uncond_embeddings.repeat_interleave(UpperCAmelCase__       ,		dim=0     )

												# For classifier free guidance, we need to do two forward passes.
												# Here we concatenate the unconditional and text embeddings into a single batch
												# to avoid doing two forward passes
												SCREAMING_SNAKE_CASE__     							=				torch.cat([uncond_embeddings, text_embeddings]     )

								# get the initial random noise unless the user supplied it

								# Unlike in other pipelines, latents need to be generated in the target device
								# for 1-to-1 results reproducibility with the CompVis implementation.
								# However this currently doesn't work in `mps`.
								SCREAMING_SNAKE_CASE__     							=				(batch_size, self.unet.config.in_channels, height // 8, width // 8)
								SCREAMING_SNAKE_CASE__     							=				text_embeddings.dtype
								if latents is None:
												if self.device.type == "mps":
																# randn does not work reproducibly on mps
																SCREAMING_SNAKE_CASE__     							=				torch.randn(UpperCAmelCase__       ,		generator=UpperCAmelCase__       ,		device="cpu"       ,		dtype=UpperCAmelCase__     ).to(
																    self.device     )
												else:
																SCREAMING_SNAKE_CASE__     							=				torch.randn(UpperCAmelCase__       ,		generator=UpperCAmelCase__       ,		device=self.device       ,		dtype=UpperCAmelCase__     )
								else:
												if latents.shape != latents_shape:
																raise ValueError(f'''Unexpected latents shape, got {latents.shape}, expected {latents_shape}'''     )
												SCREAMING_SNAKE_CASE__     							=				latents.to(self.device     )

								# scale the initial noise by the standard deviation required by the scheduler
								SCREAMING_SNAKE_CASE__     							=				latents * self.scheduler.init_noise_sigma

								# prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
								# eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
								# eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
								# and should be between [0, 1]
								SCREAMING_SNAKE_CASE__     							=				"eta" in set(inspect.signature(self.scheduler.step     ).parameters.keys()     )
								SCREAMING_SNAKE_CASE__     							=				{}
								if accepts_eta:
												SCREAMING_SNAKE_CASE__     							=				eta

								# check if the scheduler accepts generator
								SCREAMING_SNAKE_CASE__     							=				"generator" in set(inspect.signature(self.scheduler.step     ).parameters.keys()     )
								if accepts_generator:
												SCREAMING_SNAKE_CASE__     							=				generator

								with self.progress_bar(total=UpperCAmelCase__     ):
												for i, t in enumerate(UpperCAmelCase__     ):
																# expand the latents if we are doing classifier free guidance
																SCREAMING_SNAKE_CASE__     							=				torch.cat([latents] * 2     ) if do_classifier_free_guidance else latents
																SCREAMING_SNAKE_CASE__     							=				self.scheduler.scale_model_input(UpperCAmelCase__       ,		UpperCAmelCase__     )

																# predict the noise residual
																SCREAMING_SNAKE_CASE__     							=				self.unet(UpperCAmelCase__       ,		UpperCAmelCase__       ,		encoder_hidden_states=UpperCAmelCase__     ).sample

																# perform classifier free guidance
																if do_classifier_free_guidance:
																				SCREAMING_SNAKE_CASE__							,      SCREAMING_SNAKE_CASE__     							=				noise_pred.chunk(2     )
																				SCREAMING_SNAKE_CASE__     							=				noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

																# perform clip guidance
																if clip_guidance_scale > 0:
																				SCREAMING_SNAKE_CASE__     							=				(
																				    text_embeddings.chunk(2     )[1] if do_classifier_free_guidance else text_embeddings
																				)
																				SCREAMING_SNAKE_CASE__							,      SCREAMING_SNAKE_CASE__     							=				self.cond_fn(
																				    UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		)

																# compute the previous noisy sample x_t -> x_t-1
																SCREAMING_SNAKE_CASE__     							=				self.scheduler.step(UpperCAmelCase__       ,		UpperCAmelCase__       ,		UpperCAmelCase__       ,		**UpperCAmelCase__     ).prev_sample

        # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
								SCREAMING_SNAKE_CASE__     							=				1 / 0.18_215 * latents
								SCREAMING_SNAKE_CASE__     							=				self.vae.decode(UpperCAmelCase__     ).sample

								SCREAMING_SNAKE_CASE__     							=				(image / 2 + 0.5).clamp(0       ,		1     )
								SCREAMING_SNAKE_CASE__     							=				image.cpu().permute(0       ,		2       ,		3       ,		1     ).numpy()

								if output_type == "pil":
												SCREAMING_SNAKE_CASE__     							=				self.numpy_to_pil(UpperCAmelCase__     )

								if not return_dict:
												return (image, None)

								return StableDiffusionPipelineOutput(images=UpperCAmelCase__       ,		nsfw_content_detected=UpperCAmelCase__     )




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