





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,
)


lowerCAmelCase							:       str					 =	logging.get_logger(__name__)  # pylint: disable=invalid-name

lowerCAmelCase							:       List[Any]					 =	"""\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 		lowerCAmelCase  (	UpperCamelCase__   :   Any       ,			UpperCamelCase__   :   Optional[Any]       ,			UpperCamelCase__   :   Optional[Any]=8					)      ->    int:

						"""simple docstring"""





						__SCREAMING_SNAKE_CASE:				Optional[int]           =   height // scale_factor**2
						if height % scale_factor**2 != 0:
												new_height += 1
						__SCREAMING_SNAKE_CASE:				Union[str, Any]           =   width // scale_factor**2
						if width % scale_factor**2 != 0:
												new_width += 1
						return new_height * scale_factor, new_width * scale_factor





class 				a			(      __lowercase			):






				def __init__(  self			, _lowerCAmelCase			, _lowerCAmelCase			, _lowerCAmelCase			, ):

										"""simple docstring"""




										super().__init__()

										self.register_modules(
										    unet=_lowerCAmelCase			, scheduler=_lowerCAmelCase			, movq=_lowerCAmelCase			, )
										__SCREAMING_SNAKE_CASE:				Optional[int]           =   2 ** (len(self.movq.config.block_out_channels					) - 1)






				def 			snake_case_    (  self			, _lowerCAmelCase			, _lowerCAmelCase			, _lowerCAmelCase			, _lowerCAmelCase			, _lowerCAmelCase			, _lowerCAmelCase					):

										"""simple docstring"""




										if latents is None:
																__SCREAMING_SNAKE_CASE:				int           =   randn_tensor(_lowerCAmelCase			, generator=_lowerCAmelCase			, device=_lowerCAmelCase			, dtype=_lowerCAmelCase					)
										else:
																if latents.shape != shape:
																						raise ValueError(f"""Unexpected latents shape, got {latents.shape}, expected {shape}"""					)
																__SCREAMING_SNAKE_CASE:				Optional[Any]           =   latents.to(_lowerCAmelCase					)

										__SCREAMING_SNAKE_CASE:				Dict           =   latents * scheduler.init_noise_sigma
										return latents






				def 			snake_case_    (  self			, _lowerCAmelCase=0					):

										"""simple docstring"""




										if is_accelerate_available():
																from accelerate import cpu_offload
										else:
																raise ImportError('''Please install accelerate via `pip install accelerate`'''					)

										__SCREAMING_SNAKE_CASE:				List[str]           =   torch.device(f"""cuda:{gpu_id}"""					)

										__SCREAMING_SNAKE_CASE:				Dict           =   [
										    self.unet,
										    self.movq,
										]
										for cpu_offloaded_model in models:
																if cpu_offloaded_model is not None:
																						cpu_offload(_lowerCAmelCase			, _lowerCAmelCase					)






				def 			snake_case_    (  self			, _lowerCAmelCase=0					):

										"""simple docstring"""




										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.'''					)

										__SCREAMING_SNAKE_CASE:				List[str]           =   torch.device(f"""cuda:{gpu_id}"""					)

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

										__SCREAMING_SNAKE_CASE:				int           =   None
										for cpu_offloaded_model in [self.unet, self.movq]:
																__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE:				Optional[Any]           =   cpu_offload_with_hook(_lowerCAmelCase			, _lowerCAmelCase			, prev_module_hook=_lowerCAmelCase					)

										# We'll offload the last model manually.
										__SCREAMING_SNAKE_CASE:				Any           =   hook






				@property
				# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
				def 			snake_case_    (  self					):

										"""simple docstring"""




										if not hasattr(self.unet			, '''_hf_hook'''					):
																return self.device
										for module in self.unet.modules():
																if (
																    hasattr(_lowerCAmelCase			, '''_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(_lowerCAmelCase					)
				def __call__(  self			, _lowerCAmelCase			, _lowerCAmelCase			, _lowerCAmelCase = 512			, _lowerCAmelCase = 512			, _lowerCAmelCase = 100			, _lowerCAmelCase = 4.0			, _lowerCAmelCase = 1			, _lowerCAmelCase = None			, _lowerCAmelCase = None			, _lowerCAmelCase = "pil"			, _lowerCAmelCase = True			, ):

										"""simple docstring"""




										__SCREAMING_SNAKE_CASE:				Optional[Any]           =   self._execution_device

										__SCREAMING_SNAKE_CASE:				Optional[Any]           =   guidance_scale > 1.0

										if isinstance(_lowerCAmelCase			, _lowerCAmelCase					):
																__SCREAMING_SNAKE_CASE:				int           =   torch.cat(_lowerCAmelCase			, dim=0					)
										__SCREAMING_SNAKE_CASE:				Union[str, Any]           =   image_embeds.shape[0] * num_images_per_prompt
										if isinstance(_lowerCAmelCase			, _lowerCAmelCase					):
																__SCREAMING_SNAKE_CASE:				List[Any]           =   torch.cat(_lowerCAmelCase			, dim=0					)

										if do_classifier_free_guidance:
																__SCREAMING_SNAKE_CASE:				Any           =   image_embeds.repeat_interleave(_lowerCAmelCase			, dim=0					)
																__SCREAMING_SNAKE_CASE:				Union[str, Any]           =   negative_image_embeds.repeat_interleave(_lowerCAmelCase			, dim=0					)

										__SCREAMING_SNAKE_CASE:				Tuple           =   torch.cat([negative_image_embeds, image_embeds]			, dim=0					).to(dtype=self.unet.dtype			, device=_lowerCAmelCase					)

										self.scheduler.set_timesteps(_lowerCAmelCase			, device=_lowerCAmelCase					)
										__SCREAMING_SNAKE_CASE:				Union[str, Any]           =   self.scheduler.timesteps

										__SCREAMING_SNAKE_CASE:				List[Any]           =   self.unet.config.in_channels

										__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE:				Dict           =   downscale_height_and_width(_lowerCAmelCase			, _lowerCAmelCase			, self.movq_scale_factor					)

										# create initial latent
										__SCREAMING_SNAKE_CASE:				str           =   self.prepare_latents(
										    (batch_size, num_channels_latents, height, width)			, image_embeds.dtype			, _lowerCAmelCase			, _lowerCAmelCase			, _lowerCAmelCase			, self.scheduler			, )

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

																__SCREAMING_SNAKE_CASE:				Optional[int]           =   {'''image_embeds''': image_embeds}
																__SCREAMING_SNAKE_CASE:				Optional[Any]           =   self.unet(
																    sample=_lowerCAmelCase			, timestep=_lowerCAmelCase			, encoder_hidden_states=_lowerCAmelCase			, added_cond_kwargs=_lowerCAmelCase			, return_dict=_lowerCAmelCase			, )[0]

																if do_classifier_free_guidance:
																						__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE:				Optional[int]           =   noise_pred.split(latents.shape[1]			, dim=1					)
																						__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE:				Optional[Any]           =   noise_pred.chunk(2					)
																						__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE:				List[Any]           =   variance_pred.chunk(2					)
																						__SCREAMING_SNAKE_CASE:				Union[str, Any]           =   noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
																						__SCREAMING_SNAKE_CASE:				Optional[int]           =   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"]
																):
																						__SCREAMING_SNAKE_CASE       ,__SCREAMING_SNAKE_CASE:				Optional[Any]           =   noise_pred.split(latents.shape[1]			, dim=1					)

																# compute the previous noisy sample x_t -> x_t-1
																__SCREAMING_SNAKE_CASE:				Optional[Any]           =   self.scheduler.step(
																    _lowerCAmelCase			, _lowerCAmelCase			, _lowerCAmelCase			, generator=_lowerCAmelCase			, )[0]
										# post-processing
										__SCREAMING_SNAKE_CASE:				List[str]           =   self.movq.decode(_lowerCAmelCase			, force_not_quantize=_lowerCAmelCase					)['''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"]:
																__SCREAMING_SNAKE_CASE:				List[str]           =   image * 0.5 + 0.5
																__SCREAMING_SNAKE_CASE:				int           =   image.clamp(0			, 1					)
																__SCREAMING_SNAKE_CASE:				Any           =   image.cpu().permute(0			, 2			, 3			, 1					).float().numpy()

										if output_type == "pil":
																__SCREAMING_SNAKE_CASE:				str           =   self.numpy_to_pil(_lowerCAmelCase					)

										if not return_dict:
																return (image,)

										return ImagePipelineOutput(images=_lowerCAmelCase					)






import sys

lowercase_   							=  (
    '73167176531330624919225119674426574742355349194934'
    '96983520312774506326239578318016984801869478851843'
    '85861560789112949495459501737958331952853208805511'
    '12540698747158523863050715693290963295227443043557'
    '66896648950445244523161731856403098711121722383113'
    '62229893423380308135336276614282806444486645238749'
    '30358907296290491560440772390713810515859307960866'
    '70172427121883998797908792274921901699720888093776'
    '65727333001053367881220235421809751254540594752243'
    '52584907711670556013604839586446706324415722155397'
    '53697817977846174064955149290862569321978468622482'
    '83972241375657056057490261407972968652414535100474'
    '82166370484403199890008895243450658541227588666881'
    '16427171479924442928230863465674813919123162824586'
    '17866458359124566529476545682848912883142607690042'
    '24219022671055626321111109370544217506941658960408'
    '07198403850962455444362981230987879927244284909188'
    '84580156166097919133875499200524063689912560717606'
    '05886116467109405077541002256983155200055935729725'
    '71636269561882670428252483600823257530420752963450'
)
def 	a (     A__      :  str = N	)       -> int:





      """simple docstring"""



      _lowercase      			=-sys.maxsize - 1
      for i in range(len(A__	) - 12	):
            _lowercase      			=1
            for j in range(13	):
                  product *= int(n[i + j]	)
            if product > largest_product:
                  _lowercase      			=product
      return largest_product


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


