


import os
from math import logaa







def     lowerCAmelCase_					( __lowerCamelCase = "base_exp.txt"     ):
       __snake_case		:      float										=       0
       __snake_case		:      int										=       0
       for i, line in enumerate(open(os.path.join(os.path.dirname(__lowerCamelCase     )							,     __lowerCamelCase     )     )     ):
              __snake_case		:      Any										=       list(map(__lowerCamelCase							,     line.split(","     )     )     )
              if x * logaa(__lowerCamelCase     ) > largest:
                     __snake_case		:      Tuple										=       x * logaa(__lowerCamelCase     )
                     __snake_case		:      List[Any]										=       i + 1
       return result


if __name__ == "__main__":
   print(solution())





from typing import List, Optional, Union

import torch
from transformers import (
    XLMRobertaTokenizer,
)

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


_snake_case					:		Optional[int]      =    logging.get_logger(__name__)  # pylint: disable=invalid-name

_snake_case					:		Union[str, Any]      =    "\n    Examples:\n        ```py\n        >>> from diffusers import KandinskyPipeline, KandinskyPriorPipeline\n        >>> import torch\n\n        >>> pipe_prior = KandinskyPriorPipeline.from_pretrained(\"kandinsky-community/Kandinsky-2-1-prior\")\n        >>> pipe_prior.to(\"cuda\")\n\n        >>> prompt = \"red cat, 4k photo\"\n        >>> out = pipe_prior(prompt)\n        >>> image_emb = out.image_embeds\n        >>> negative_image_emb = out.negative_image_embeds\n\n        >>> pipe = KandinskyPipeline.from_pretrained(\"kandinsky-community/kandinsky-2-1\")\n        >>> pipe.to(\"cuda\")\n\n        >>> image = pipe(\n        ...     prompt,\n        ...     image_embeds=image_emb,\n        ...     negative_image_embeds=negative_image_emb,\n        ...     height=768,\n        ...     width=768,\n        ...     num_inference_steps=100,\n        ... ).images\n\n        >>> image[0].save(\"cat.png\")\n        ```\n"







def     lowerCAmelCase_					( __lowerCamelCase							,     __lowerCamelCase							,     __lowerCamelCase=8     ):
							__snake_case		:      List[Any]										=       h // scale_factor**2
							if h % scale_factor**2 != 0:
														new_h += 1
							__snake_case		:      Optional[int]										=       w // scale_factor**2
							if w % scale_factor**2 != 0:
														new_w += 1
							return new_h * scale_factor, new_w * scale_factor

class     a		(_lowerCAmelCase				):




							"""simple docstring"""


							def __init__(							self	:  Union[str, Any]   ,     lowerCamelCase	:  MultilingualCLIP   ,     lowerCamelCase	:  XLMRobertaTokenizer   ,     lowerCamelCase	:  UNetaDConditionModel   ,     lowerCamelCase	:  Union[DDIMScheduler, DDPMScheduler]   ,     lowerCamelCase	:  VQModel   ,     )     ->   Optional[int]:
														super().__init__()

														self.register_modules(
														    text_encoder=lowerCamelCase   ,     tokenizer=lowerCamelCase   ,     unet=lowerCamelCase   ,     scheduler=lowerCamelCase   ,     movq=lowerCamelCase   ,     )
														__snake_case		:      List[Any]										=       2 ** (len(self.movq.config.block_out_channels    ) - 1)

							def    __snake_case (							self	:  Any   ,     lowerCamelCase	:  Dict   ,     lowerCamelCase	:  List[Any]   ,     lowerCamelCase	:  Optional[int]   ,     lowerCamelCase	:  Union[str, Any]   ,     lowerCamelCase	:  Optional[Any]   ,     lowerCamelCase	:  int    )     ->   Any:
														if latents is None:
																					__snake_case		:      str										=       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}'    )
																					__snake_case		:      Optional[int]										=       latents.to(lowerCamelCase    )

														__snake_case		:      List[Any]										=       latents * scheduler.init_noise_sigma
														return latents

							def    __snake_case (							self	:  Optional[int]   ,     lowerCamelCase	:  int   ,     lowerCamelCase	:  Any   ,     lowerCamelCase	:  Any   ,     lowerCamelCase	:  List[Any]   ,     lowerCamelCase	:  str=None   ,     )     ->   List[str]:
														__snake_case		:      Tuple										=       len(lowerCamelCase    ) if isinstance(lowerCamelCase   ,     lowerCamelCase    ) else 1
														# get prompt text embeddings
														__snake_case		:      Optional[int]										=       self.tokenizer(
														    lowerCamelCase   ,     padding="max_length"   ,     truncation=lowerCamelCase   ,     max_length=77   ,     return_attention_mask=lowerCamelCase   ,     add_special_tokens=lowerCamelCase   ,     return_tensors="pt"   ,     )

														__snake_case		:      List[str]										=       text_inputs.input_ids
														__snake_case		:      List[Any]										=       self.tokenizer(lowerCamelCase   ,     padding="longest"   ,     return_tensors="pt"    ).input_ids

														if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(lowerCamelCase   ,     lowerCamelCase    ):
																					__snake_case		:      Optional[Any]										=       self.tokenizer.batch_decode(untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1]    )
																					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}'    )

														__snake_case		:      Any										=       text_input_ids.to(lowerCamelCase    )
														__snake_case		:      List[str]										=       text_inputs.attention_mask.to(lowerCamelCase    )

														__snake_case			,      __snake_case		:      List[str]										=       self.text_encoder(
														    input_ids=lowerCamelCase   ,     attention_mask=lowerCamelCase    )

														__snake_case		:      List[Any]										=       prompt_embeds.repeat_interleave(lowerCamelCase   ,     dim=0    )
														__snake_case		:      List[str]										=       text_encoder_hidden_states.repeat_interleave(lowerCamelCase   ,     dim=0    )
														__snake_case		:      Optional[int]										=       text_mask.repeat_interleave(lowerCamelCase   ,     dim=0    )

														if do_classifier_free_guidance:
																					__snake_case		:      List[str]
																					if negative_prompt is None:
																												__snake_case		:      Any										=       [""] * batch_size
																					elif type(lowerCamelCase    ) is not type(lowerCamelCase    ):
																												raise TypeError(
																												    F'`negative_prompt` should be the same type to `prompt`, but got {type(lowerCamelCase    )} !='
																												    F' {type(lowerCamelCase    )}.'    )
																					elif isinstance(lowerCamelCase   ,     lowerCamelCase    ):
																												__snake_case		:      List[Any]										=       [negative_prompt]
																					elif batch_size != len(lowerCamelCase    ):
																												raise ValueError(
																												    F'`negative_prompt`: {negative_prompt} has batch size {len(lowerCamelCase    )}, but `prompt`:'
																												    F' {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches'
																												    " the batch size of `prompt`."    )
																					else:
																												__snake_case		:      int										=       negative_prompt

																					__snake_case		:      Dict										=       self.tokenizer(
																					    lowerCamelCase   ,     padding="max_length"   ,     max_length=77   ,     truncation=lowerCamelCase   ,     return_attention_mask=lowerCamelCase   ,     add_special_tokens=lowerCamelCase   ,     return_tensors="pt"   ,     )
																					__snake_case		:      Dict										=       uncond_input.input_ids.to(lowerCamelCase    )
																					__snake_case		:      List[Any]										=       uncond_input.attention_mask.to(lowerCamelCase    )

																					__snake_case			,      __snake_case		:      Tuple										=       self.text_encoder(
																					    input_ids=lowerCamelCase   ,     attention_mask=lowerCamelCase    )

																					# duplicate unconditional embeddings for each generation per prompt, using mps friendly method

																					__snake_case		:      Dict										=       negative_prompt_embeds.shape[1]
																					__snake_case		:      int										=       negative_prompt_embeds.repeat(1   ,     lowerCamelCase    )
																					__snake_case		:      List[str]										=       negative_prompt_embeds.view(batch_size * num_images_per_prompt   ,     lowerCamelCase    )

																					__snake_case		:      Union[str, Any]										=       uncond_text_encoder_hidden_states.shape[1]
																					__snake_case		:      Tuple										=       uncond_text_encoder_hidden_states.repeat(1   ,     lowerCamelCase   ,     1    )
																					__snake_case		:      str										=       uncond_text_encoder_hidden_states.view(
																					    batch_size * num_images_per_prompt   ,     lowerCamelCase   ,     -1    )
																					__snake_case		:      Optional[int]										=       uncond_text_mask.repeat_interleave(lowerCamelCase   ,     dim=0    )

																					# done duplicates

																					# 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
																					__snake_case		:      Optional[int]										=       torch.cat([negative_prompt_embeds, prompt_embeds]    )
																					__snake_case		:      List[Any]										=       torch.cat([uncond_text_encoder_hidden_states, text_encoder_hidden_states]    )

																					__snake_case		:      Any										=       torch.cat([uncond_text_mask, text_mask]    )

														return prompt_embeds, text_encoder_hidden_states, text_mask

							def    __snake_case (							self	:  List[str]   ,     lowerCamelCase	:  Dict=0    )     ->   Tuple:
														if is_accelerate_available():
																					from accelerate import cpu_offload
														else:
																					raise ImportError("Please install accelerate via `pip install accelerate`"    )

														__snake_case		:      Optional[int]										=       torch.device(F'cuda:{gpu_id}'    )

														__snake_case		:      Optional[Any]										=       [
														    self.unet,
														    self.text_encoder,
														    self.movq,
														]
														for cpu_offloaded_model in models:
																					if cpu_offloaded_model is not None:
																												cpu_offload(lowerCamelCase   ,     lowerCamelCase    )

							def    __snake_case (							self	:  List[Any]   ,     lowerCamelCase	:  int=0    )     ->   Optional[int]:
														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."    )

														__snake_case		:      Optional[Any]										=       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)

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

														if self.safety_checker is not None:
																					__snake_case			,      __snake_case		:      Optional[int]										=       cpu_offload_with_hook(self.safety_checker   ,     lowerCamelCase   ,     prev_module_hook=lowerCamelCase    )

														# We'll offload the last model manually.
														__snake_case		:      str										=       hook

							@property
							# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
							def    __snake_case (							self	:  List[Any]    )     ->   Optional[int]:
														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	:  Dict   ,     lowerCamelCase	:  Union[str, List[str]]   ,     lowerCamelCase	:  Union[torch.FloatTensor, List[torch.FloatTensor]]   ,     lowerCamelCase	:  Union[torch.FloatTensor, List[torch.FloatTensor]]   ,     lowerCamelCase	:  Optional[Union[str, List[str]]] = None   ,     lowerCamelCase	:  int = 512   ,     lowerCamelCase	:  int = 512   ,     lowerCamelCase	:  int = 100   ,     lowerCamelCase	:  float = 4.0   ,     lowerCamelCase	:  int = 1   ,     lowerCamelCase	:  Optional[Union[torch.Generator, List[torch.Generator]]] = None   ,     lowerCamelCase	:  Optional[torch.FloatTensor] = None   ,     lowerCamelCase	:  Optional[str] = "pil"   ,     lowerCamelCase	:  bool = True   ,     )     ->   List[Any]:

														if isinstance(lowerCamelCase   ,     lowerCamelCase    ):
																					__snake_case		:      Optional[int]										=       1
														elif isinstance(lowerCamelCase   ,     lowerCamelCase    ):
																					__snake_case		:      List[Any]										=       len(lowerCamelCase    )
														else:
																					raise ValueError(F'`prompt` has to be of type `str` or `list` but is {type(lowerCamelCase    )}'    )

														__snake_case		:      Any										=       self._execution_device

														__snake_case		:      Any										=       batch_size * num_images_per_prompt
														__snake_case		:      Any										=       guidance_scale > 1.0

														__snake_case			,      __snake_case			,      __snake_case		:      Optional[Any]										=       self._encode_prompt(
														    lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase   ,     lowerCamelCase    )

														if isinstance(lowerCamelCase   ,     lowerCamelCase    ):
																					__snake_case		:      List[Any]										=       torch.cat(lowerCamelCase   ,     dim=0    )
														if isinstance(lowerCamelCase   ,     lowerCamelCase    ):
																					__snake_case		:      str										=       torch.cat(lowerCamelCase   ,     dim=0    )

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

														__snake_case		:      str										=       torch.cat([negative_image_embeds, image_embeds]   ,     dim=0    ).to(
														    dtype=prompt_embeds.dtype   ,     device=lowerCamelCase    )

														self.scheduler.set_timesteps(lowerCamelCase   ,     device=lowerCamelCase    )
														__snake_case		:      Tuple										=       self.scheduler.timesteps

														__snake_case		:      Union[str, Any]										=       self.unet.config.in_channels

														__snake_case			,      __snake_case		:      Tuple										=       get_new_h_w(lowerCamelCase   ,     lowerCamelCase   ,     self.movq_scale_factor    )

														# create initial latent
														__snake_case		:      Any										=       self.prepare_latents(
														    (batch_size, num_channels_latents, height, width)   ,     text_encoder_hidden_states.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
																					__snake_case		:      Any										=       torch.cat([latents] * 2    ) if do_classifier_free_guidance else latents

																					__snake_case		:      int										=       {"text_embeds": prompt_embeds, "image_embeds": image_embeds}
																					__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:
																												__snake_case			,      __snake_case		:      Any										=       noise_pred.split(latents.shape[1]   ,     dim=1    )
																												__snake_case			,      __snake_case		:      Union[str, Any]										=       noise_pred.chunk(2    )
																												__snake_case			,      __snake_case		:      str										=       variance_pred.chunk(2    )
																												__snake_case		:      Optional[Any]										=       noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
																												__snake_case		:      Union[str, 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"]
																					):
																												__snake_case			,      __snake_case		:      Union[str, Any]										=       noise_pred.split(latents.shape[1]   ,     dim=1    )

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

														if output_type == "pil":
																					__snake_case		:      str										=       self.numpy_to_pil(lowerCamelCase    )

														if not return_dict:
																					return (image,)

														return ImagePipelineOutput(images=lowerCamelCase    )

