



'''simple docstring'''






from typing import List, Optional, Union

import torch

from ...models import UNetaDConditionModel, VQModel
from ...pipelines import DiffusionPipeline
from ...pipelines.pipeline_utils import ImagePipelineOutput
from ...schedulers import DDPMScheduler
from ...utils import (
    is_accelerate_available,
    is_accelerate_version,
    logging,
    randn_tensor,
    replace_example_docstring,
)


UpperCamelCase__:   Dict								=			logging.get_logger(__name__)  # pylint: disable=invalid-name

UpperCamelCase__:   str								=			"\n    Examples:\n        ```py\n        >>> from diffusers import KandinskyV22Pipeline, KandinskyV22PriorPipeline\n        >>> import torch\n\n        >>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained(\"kandinsky-community/kandinsky-2-2-prior\")\n        >>> pipe_prior.to(\"cuda\")\n        >>> prompt = \"red cat, 4k photo\"\n        >>> out = pipe_prior(prompt)\n        >>> image_emb = out.image_embeds\n        >>> zero_image_emb = out.negative_image_embeds\n        >>> pipe = KandinskyV22Pipeline.from_pretrained(\"kandinsky-community/kandinsky-2-2-decoder\")\n        >>> pipe.to(\"cuda\")\n        >>> image = pipe(\n        ...     image_embeds=image_emb,\n        ...     negative_image_embeds=zero_image_emb,\n        ...     height=768,\n        ...     width=768,\n        ...     num_inference_steps=50,\n        ... ).images\n        >>> image[0].save(\"cat.png\")\n        ```\n"


def  snake_case_     (					_lowerCAmelCase  :						List[Any]   ,      _lowerCAmelCase  :						Optional[Any]   ,      _lowerCAmelCase  :						Optional[Any]=8  )      ->   Any:
							UpperCAmelCase :       Union[str, Any] 							=		height // scale_factor**2
							if height % scale_factor**2 != 0:
														new_height += 1
							UpperCAmelCase :       List[Any] 							=		width // scale_factor**2
							if width % scale_factor**2 != 0:
														new_width += 1
							return new_height * scale_factor, new_width * scale_factor




class 				SCREAMING_SNAKE_CASE(							A__			):







	"""simple docstring"""






	def __init__(						self			:     List[str]		,			__snake_case			:     UNetaDConditionModel		,			__snake_case			:     DDPMScheduler		,			__snake_case			:     VQModel		,			)			->		Dict:
								super().__init__()

								self.register_modules(
								    unet=__snake_case		,			scheduler=__snake_case		,			movq=__snake_case		,			)
								UpperCAmelCase :       Any 							=		2 ** (len(self.movq.config.block_out_channels		) - 1)







	def      A	(						self			:     Tuple		,			__snake_case			:     Tuple		,			__snake_case			:     List[str]		,			__snake_case			:     Any		,			__snake_case			:     int		,			__snake_case			:     Optional[Any]		,			__snake_case			:     int		)			->		Optional[int]:
								if latents is None:
															UpperCAmelCase :       Optional[int] 							=		randn_tensor(__snake_case		,			generator=__snake_case		,			device=__snake_case		,			dtype=__snake_case		)
								else:
															if latents.shape != shape:
																						raise ValueError(F"""Unexpected latents shape, got {latents.shape}, expected {shape}"""		)
															UpperCAmelCase :       List[Any] 							=		latents.to(__snake_case		)

								UpperCAmelCase :       Optional[int] 							=		latents * scheduler.init_noise_sigma
								return latents







	def      A	(						self			:     Dict		,			__snake_case			:     Dict=0		)			->		Any:
								if is_accelerate_available():
															from accelerate import cpu_offload
								else:
															raise ImportError('''Please install accelerate via `pip install accelerate`'''		)

								UpperCAmelCase :       Tuple 							=		torch.device(F"""cuda:{gpu_id}"""		)

								UpperCAmelCase :       Tuple 							=		[
								    self.unet,
								    self.movq,
								]
								for cpu_offloaded_model in models:
															if cpu_offloaded_model is not None:
																						cpu_offload(__snake_case		,			__snake_case		)







	def      A	(						self			:     List[str]		,			__snake_case			:     Tuple=0		)			->		List[Any]:
								if is_accelerate_available() and is_accelerate_version('''>='''		,			'''0.17.0.dev0'''		):
															from accelerate import cpu_offload_with_hook
								else:
															raise ImportError('''`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.'''		)

								UpperCAmelCase :       Dict 							=		torch.device(F"""cuda:{gpu_id}"""		)

								if self.device.type != "cpu":
															self.to('''cpu'''		,			silence_dtype_warnings=__snake_case		)
															torch.cuda.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)

								UpperCAmelCase :       Union[str, Any] 							=		None
								for cpu_offloaded_model in [self.unet, self.movq]:
															UpperCAmelCase							,		UpperCAmelCase :       Any 							=		cpu_offload_with_hook(__snake_case		,			__snake_case		,			prev_module_hook=__snake_case		)

								# We'll offload the last model manually.
								UpperCAmelCase :       Tuple 							=		hook







	@property
	# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
	def      A	(						self			:     List[str]		)			->		Dict:
								if not hasattr(self.unet		,			'''_hf_hook'''		):
															return self.device
								for module in self.unet.modules():
															if (
															    hasattr(__snake_case		,			'''_hf_hook'''		)
															    and hasattr(module._hf_hook		,			'''execution_device'''		)
															    and module._hf_hook.execution_device is not None
															):
																						return torch.device(module._hf_hook.execution_device		)
								return self.device







	@torch.no_grad()
	@replace_example_docstring(__snake_case		)
	def __call__(						self			:     Tuple		,			__snake_case			:     Union[torch.FloatTensor, List[torch.FloatTensor]]		,			__snake_case			:     Union[torch.FloatTensor, List[torch.FloatTensor]]		,			__snake_case			:     int = 512		,			__snake_case			:     int = 512		,			__snake_case			:     int = 100		,			__snake_case			:     float = 4.0		,			__snake_case			:     int = 1		,			__snake_case			:     Optional[Union[torch.Generator, List[torch.Generator]]] = None		,			__snake_case			:     Optional[torch.FloatTensor] = None		,			__snake_case			:     Optional[str] = "pil"		,			__snake_case			:     bool = True		,			)			->		str:
								UpperCAmelCase :       int 							=		self._execution_device

								UpperCAmelCase :       Optional[int] 							=		guidance_scale > 1.0

								if isinstance(__snake_case		,			__snake_case		):
															UpperCAmelCase :       Union[str, Any] 							=		torch.cat(__snake_case		,			dim=0		)
								UpperCAmelCase :       str 							=		image_embeds.shape[0] * num_images_per_prompt
								if isinstance(__snake_case		,			__snake_case		):
															UpperCAmelCase :       Tuple 							=		torch.cat(__snake_case		,			dim=0		)

								if do_classifier_free_guidance:
															UpperCAmelCase :       Optional[Any] 							=		image_embeds.repeat_interleave(__snake_case		,			dim=0		)
															UpperCAmelCase :       int 							=		negative_image_embeds.repeat_interleave(__snake_case		,			dim=0		)

								UpperCAmelCase :       Union[str, Any] 							=		torch.cat([negative_image_embeds, image_embeds]		,			dim=0		).to(dtype=self.unet.dtype		,			device=__snake_case		)

								self.scheduler.set_timesteps(__snake_case		,			device=__snake_case		)
								UpperCAmelCase :       Optional[int] 							=		self.scheduler.timesteps

								UpperCAmelCase :       Dict 							=		self.unet.config.in_channels

								UpperCAmelCase							,		UpperCAmelCase :       str 							=		downscale_height_and_width(__snake_case		,			__snake_case		,			self.movq_scale_factor		)

								# create initial latent
								UpperCAmelCase :       Optional[Any] 							=		self.prepare_latents(
								    (batch_size, num_channels_latents, height, width)		,			image_embeds.dtype		,			__snake_case		,			__snake_case		,			__snake_case		,			self.scheduler		,			)

								for i, t in enumerate(self.progress_bar(__snake_case		)		):
															# expand the latents if we are doing classifier free guidance
															UpperCAmelCase :       Optional[Any] 							=		torch.cat([latents] * 2		) if do_classifier_free_guidance else latents

															UpperCAmelCase :       str 							=		{'''image_embeds''': image_embeds}
															UpperCAmelCase :       Tuple 							=		self.unet(
															    sample=__snake_case		,			timestep=__snake_case		,			encoder_hidden_states=__snake_case		,			added_cond_kwargs=__snake_case		,			return_dict=__snake_case		,			)[0]

															if do_classifier_free_guidance:
																						UpperCAmelCase							,		UpperCAmelCase :       List[Any] 							=		noise_pred.split(latents.shape[1]		,			dim=1		)
																						UpperCAmelCase							,		UpperCAmelCase :       str 							=		noise_pred.chunk(2		)
																						UpperCAmelCase							,		UpperCAmelCase :       int 							=		variance_pred.chunk(2		)
																						UpperCAmelCase :       Any 							=		noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
																						UpperCAmelCase :       Optional[Any] 							=		torch.cat([noise_pred, variance_pred_text]		,			dim=1		)

															if not (
															    hasattr(self.scheduler.config		,			'''variance_type'''		)
															    and self.scheduler.config.variance_type in ["learned", "learned_range"]
															):
																						UpperCAmelCase							,		UpperCAmelCase :       Dict 							=		noise_pred.split(latents.shape[1]		,			dim=1		)

															# compute the previous noisy sample x_t -> x_t-1
															UpperCAmelCase :       Optional[int] 							=		self.scheduler.step(
															    __snake_case		,			__snake_case		,			__snake_case		,			generator=__snake_case		,			)[0]
								# post-processing
								UpperCAmelCase :       Optional[int] 							=		self.movq.decode(__snake_case		,			force_not_quantize=__snake_case		)['''sample''']

								if output_type not in ["pt", "np", "pil"]:
															raise ValueError(F"""Only the output types `pt`, `pil` and `np` are supported not output_type={output_type}"""		)

								if output_type in ["np", "pil"]:
															UpperCAmelCase :       List[Any] 							=		image * 0.5 + 0.5
															UpperCAmelCase :       int 							=		image.clamp(0		,			1		)
															UpperCAmelCase :       Any 							=		image.cpu().permute(0		,			2		,			3		,			1		).float().numpy()

								if output_type == "pil":
															UpperCAmelCase :       Optional[Any] 							=		self.numpy_to_pil(__snake_case		)

								if not return_dict:
															return (image,)

								return ImagePipelineOutput(images=__snake_case		)






"""simple docstring"""






def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase )  ->  int:
   if n == 1 or not isinstance(__UpperCAmelCase       ,    __UpperCAmelCase ):
      return 0
   elif n == 2:
      return 1
   else:
      lowercase__:   List[Any]					=      [0, 1]
      for i in range(2       ,    n + 1 ):
         sequence.append(sequence[i - 1] + sequence[i - 2] )

      return sequence[n]



def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase )  ->  int:
   lowercase__:   Union[str, Any]					=      0
   lowercase__:   List[Any]					=      2

   while digits < n:
      index += 1
      lowercase__:   Dict					=      len(str(fibonacci(__UpperCAmelCase ) ) )

   return index



def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase = 1_0_0_0 )  ->  int:
   return fibonacci_digits_index(__UpperCAmelCase )


if __name__ == "__main__":
       print(solution(int(str(input()).strip())))
