





import inspect
from typing import Callable, List, Optional, Union

import torch
from transformers import (
    CLIPImageProcessor,
    CLIPTextModel,
    CLIPTokenizer,
    WhisperForConditionalGeneration,
    WhisperProcessor,
)

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    LMSDiscreteScheduler,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
from diffusers.utils import logging


__lowercase       :List[Any]       =  logging.get_logger(__name__)  # pylint: disable=invalid-name



class    _a     (				lowercase__							):






							"""simple docstring"""

							def __init__(      self				:     Tuple							,	a				:     WhisperForConditionalGeneration							,	a				:     WhisperProcessor							,	a				:     AutoencoderKL							,	a				:     CLIPTextModel							,	a				:     CLIPTokenizer							,	a				:     UNetaDConditionModel							,	a				:     Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler]							,	a				:     StableDiffusionSafetyChecker							,	a				:     CLIPImageProcessor							,	)	->Union[str, Any]:
													super().__init__()

													if safety_checker is None:
																			logger.warning(
																			    f"""You have disabled the safety checker for {self.__class__} by passing `safety_checker=None`. Ensure"""
																			    " that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered"
																			    " results in services or applications open to the public. Both the diffusers team and Hugging Face"
																			    " strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling"
																			    " it only for use-cases that involve analyzing network behavior or auditing its results. For more"
																			    " information, please have a look at https://github.com/huggingface/diffusers/pull/254 ."    )

													self.register_modules(
													    speech_model=a							,	speech_processor=a							,	vae=a							,	text_encoder=a							,	tokenizer=a							,	unet=a							,	scheduler=a							,	feature_extractor=a							,	)

							def      A_  (      self				:     List[Any]							,	a				:     Optional[Union[str, int]] = "auto"    )	->int:
													if slice_size == "auto":
																			SCREAMING_SNAKE_CASE__     :				List[Any]   =					self.unet.config.attention_head_dim // 2
													self.unet.set_attention_slice(a    )

							def      A_  (      self				:     List[Any]    )	->str:
													self.enable_attention_slicing(a    )






							@torch.no_grad()
							def __call__(      self				:     str							,	a				:     str							,	a				:     Tuple=1_60_00							,	a				:     int = 5_12							,	a				:     int = 5_12							,	a				:     int = 50							,	a				:     float = 7.5							,	a				:     Optional[Union[str, List[str]]] = None							,	a				:     Optional[int] = 1							,	a				:     float = 0.0							,	a				:     Optional[torch.Generator] = None							,	a				:     Optional[torch.FloatTensor] = None							,	a				:     Optional[str] = "pil"							,	a				:     bool = True							,	a				:     Optional[Callable[[int, int, torch.FloatTensor], None]] = None							,	a				:     int = 1							,	**a				:     List[Any]							,	)	->Any:
													SCREAMING_SNAKE_CASE__     :				List[str]   =					self.speech_processor.feature_extractor(
													    a							,	return_tensors="pt"							,	sampling_rate=a    ).input_features.to(self.device    )
													SCREAMING_SNAKE_CASE__     :				str   =					self.speech_model.generate(a							,	max_length=48_00_00    )

													SCREAMING_SNAKE_CASE__     :				int   =					self.speech_processor.tokenizer.batch_decode(a							,	skip_special_tokens=a							,	normalize=a    )[
													    0
													]

													if isinstance(a							,	a    ):
																			SCREAMING_SNAKE_CASE__     :				str   =					1
													elif isinstance(a							,	a    ):
																			SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					len(a    )
													else:
																			raise ValueError(f"""`prompt` has to be of type `str` or `list` but is {type(a    )}"""    )

													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 (callback_steps is None) or (
													    callback_steps is not None and (not isinstance(a							,	a    ) or callback_steps <= 0)
													):
																			raise ValueError(
																			    f"""`callback_steps` has to be a positive integer but is {callback_steps} of type"""
																			    f""" {type(a    )}."""    )

													# get prompt text embeddings
													SCREAMING_SNAKE_CASE__     :				List[Any]   =					self.tokenizer(
													    a							,	padding="max_length"							,	max_length=self.tokenizer.model_max_length							,	return_tensors="pt"							,	)
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					text_inputs.input_ids

													if text_input_ids.shape[-1] > self.tokenizer.model_max_length:
																			SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					self.tokenizer.batch_decode(text_input_ids[:, self.tokenizer.model_max_length :]    )
																			logger.warning(
																			    "The following part of your input was truncated because CLIP can only handle sequences up to"
																			    f""" {self.tokenizer.model_max_length} tokens: {removed_text}"""    )
																			SCREAMING_SNAKE_CASE__     :				List[Any]   =					text_input_ids[:, : self.tokenizer.model_max_length]
													SCREAMING_SNAKE_CASE__     :				List[str]   =					self.text_encoder(text_input_ids.to(self.device    )    )[0]

													# duplicate text embeddings for each generation per prompt, using mps friendly method
													SCREAMING_SNAKE_CASE__,							SCREAMING_SNAKE_CASE__,							SCREAMING_SNAKE_CASE__     :				int   =					text_embeddings.shape
													SCREAMING_SNAKE_CASE__     :				Dict   =					text_embeddings.repeat(1							,	a							,	1    )
													SCREAMING_SNAKE_CASE__     :				List[str]   =					text_embeddings.view(bs_embed * num_images_per_prompt							,	a							,	-1    )

													# 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__     :				Optional[int]   =					guidance_scale > 1.0
													# get unconditional embeddings for classifier free guidance
													if do_classifier_free_guidance:
																			SCREAMING_SNAKE_CASE__     :				List[str]
																			if negative_prompt is None:
																									SCREAMING_SNAKE_CASE__     :				Dict   =					[""] * batch_size
																			elif type(a    ) is not type(a    ):
																									raise TypeError(
																									    f"""`negative_prompt` should be the same type to `prompt`, but got {type(a    )} !="""
																									    f""" {type(a    )}."""    )
																			elif isinstance(a							,	a    ):
																									SCREAMING_SNAKE_CASE__     :				Any   =					[negative_prompt]
																			elif batch_size != len(a    ):
																									raise ValueError(
																									    f"""`negative_prompt`: {negative_prompt} has batch size {len(a    )}, but `prompt`:"""
																									    f""" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"""
																									    " the batch size of `prompt`."    )
																			else:
																									SCREAMING_SNAKE_CASE__     :				List[str]   =					negative_prompt

																			SCREAMING_SNAKE_CASE__     :				Optional[int]   =					text_input_ids.shape[-1]
																			SCREAMING_SNAKE_CASE__     :				List[Any]   =					self.tokenizer(
																			    a							,	padding="max_length"							,	max_length=a							,	truncation=a							,	return_tensors="pt"							,	)
																			SCREAMING_SNAKE_CASE__     :				Optional[int]   =					self.text_encoder(uncond_input.input_ids.to(self.device    )    )[0]

																			# duplicate unconditional embeddings for each generation per prompt, using mps friendly method
																			SCREAMING_SNAKE_CASE__     :				str   =					uncond_embeddings.shape[1]
																			SCREAMING_SNAKE_CASE__     :				Any   =					uncond_embeddings.repeat(1							,	a							,	1    )
																			SCREAMING_SNAKE_CASE__     :				Any   =					uncond_embeddings.view(batch_size * num_images_per_prompt							,	a							,	-1    )

																			# 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__     :				Optional[int]   =					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__     :				Optional[int]   =					(batch_size * num_images_per_prompt, self.unet.config.in_channels, height // 8, width // 8)
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					text_embeddings.dtype
													if latents is None:
																			if self.device.type == "mps":
																									# randn does not exist on mps
																									SCREAMING_SNAKE_CASE__     :				List[str]   =					torch.randn(a							,	generator=a							,	device="cpu"							,	dtype=a    ).to(
																									    self.device    )
																			else:
																									SCREAMING_SNAKE_CASE__     :				List[Any]   =					torch.randn(a							,	generator=a							,	device=self.device							,	dtype=a    )
													else:
																			if latents.shape != latents_shape:
																									raise ValueError(f"""Unexpected latents shape, got {latents.shape}, expected {latents_shape}"""    )
																			SCREAMING_SNAKE_CASE__     :				Optional[int]   =					latents.to(self.device    )

													# set timesteps
													self.scheduler.set_timesteps(a    )

													# Some schedulers like PNDM have timesteps as arrays
													# It's more optimized to move all timesteps to correct device beforehand
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					self.scheduler.timesteps.to(self.device    )

													# scale the initial noise by the standard deviation required by the scheduler
													SCREAMING_SNAKE_CASE__     :				Optional[int]   =					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__     :				int   =					"eta" in set(inspect.signature(self.scheduler.step    ).parameters.keys()    )
													SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					{}
													if accepts_eta:
																			SCREAMING_SNAKE_CASE__     :				str   =					eta

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

																			# predict the noise residual
																			SCREAMING_SNAKE_CASE__     :				List[Any]   =					self.unet(a							,	a							,	encoder_hidden_states=a    ).sample

																			# perform guidance
																			if do_classifier_free_guidance:
																									SCREAMING_SNAKE_CASE__,							SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					noise_pred.chunk(2    )
																									SCREAMING_SNAKE_CASE__     :				Dict   =					noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

																			# compute the previous noisy sample x_t -> x_t-1
																			SCREAMING_SNAKE_CASE__     :				List[str]   =					self.scheduler.step(a							,	a							,	a							,	**a    ).prev_sample

																			# call the callback, if provided
																			if callback is not None and i % callback_steps == 0:
																									callback(a							,	a							,	a    )

													SCREAMING_SNAKE_CASE__     :				Any   =					1 / 0.1_8215 * latents
													SCREAMING_SNAKE_CASE__     :				Union[str, Any]   =					self.vae.decode(a    ).sample

													SCREAMING_SNAKE_CASE__     :				List[Any]   =					(image / 2 + 0.5).clamp(0							,	1    )

													# we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
													SCREAMING_SNAKE_CASE__     :				str   =					image.cpu().permute(0							,	2							,	3							,	1    ).float().numpy()

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

													if not return_dict:
																			return image

													return StableDiffusionPipelineOutput(images=a							,	nsfw_content_detected=a    )






def       UpperCAmelCase							(     _lowerCamelCase      :  int = 4_000_000     ):





						'''simple docstring'''


						SCREAMING_SNAKE_CASE__     :				Any   =					[0, 1]
						SCREAMING_SNAKE_CASE__     :				List[Any]   =					0
						while fib[i] <= n:
												fib.append(fib[i] + fib[i + 1]     )
												if fib[i + 2] > n:
																		break
												i += 1
						SCREAMING_SNAKE_CASE__     :				Optional[Any]   =					0
						for j in range(len(_lowerCamelCase     ) - 1     ):
												if fib[j] % 2 == 0:
																		total += fib[j]

						return total


if __name__ == "__main__":
				print(f"{solution() = }")