


"""simple docstring"""


from typing import Callable, List, Optional, Union

import PIL
import torch
from transformers import (
    CLIPImageProcessor,
    CLIPSegForImageSegmentation,
    CLIPSegProcessor,
    CLIPTextModel,
    CLIPTokenizer,
)

from diffusers import DiffusionPipeline
from diffusers.configuration_utils import FrozenDict
from diffusers.models import AutoencoderKL, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion import StableDiffusionInpaintPipeline
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
from diffusers.schedulers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler
from diffusers.utils import deprecate, is_accelerate_available, logging


A     :   str			    =			logging.get_logger(__name__)  # pylint: disable=invalid-name
class   _UpperCamelCase  (   lowerCAmelCase__		):
							'''simple docstring'''







							def __init__(     self    ,   __a    ,   __a    ,   __a    ,   __a    ,   __a    ,   __a    ,   __a    ,   __a    ,   __a    ,   ):
										super().__init__()

										if hasattr(scheduler.config    ,   "steps_offset"	) and scheduler.config.steps_offset != 1:
													__lowerCAmelCase				    =			(
													    f"The configuration file of this scheduler: {scheduler} is outdated. `steps_offset`"
													    f" should be set to 1 instead of {scheduler.config.steps_offset}. Please make sure "
													    "to update the config accordingly as leaving `steps_offset` might led to incorrect results"
													    " in future versions. If you have downloaded this checkpoint from the Hugging Face Hub,"
													    " it would be very nice if you could open a Pull request for the `scheduler/scheduler_config.json`"
													    " file"
													)
													deprecate("steps_offset!=1"    ,   "1.0.0"    ,   __a    ,   standard_warn=__a	)
													__lowerCAmelCase				    =			dict(scheduler.config	)
													__lowerCAmelCase				    =			1
													__lowerCAmelCase				    =			FrozenDict(__a	)

										if hasattr(scheduler.config    ,   "skip_prk_steps"	) and scheduler.config.skip_prk_steps is False:
													__lowerCAmelCase				    =			(
													    f"The configuration file of this scheduler: {scheduler} has not set the configuration"
													    " `skip_prk_steps`. `skip_prk_steps` should be set to True in the configuration file. Please make"
													    " sure to update the config accordingly as not setting `skip_prk_steps` in the config might lead to"
													    " incorrect results in future versions. If you have downloaded this checkpoint from the Hugging Face"
													    " Hub, it would be very nice if you could open a Pull request for the"
													    " `scheduler/scheduler_config.json` file"
													)
													deprecate("skip_prk_steps not set"    ,   "1.0.0"    ,   __a    ,   standard_warn=__a	)
													__lowerCAmelCase				    =			dict(scheduler.config	)
													__lowerCAmelCase				    =			True
													__lowerCAmelCase				    =			FrozenDict(__a	)

										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(
										    segmentation_model=__a    ,   segmentation_processor=__a    ,   vae=__a    ,   text_encoder=__a    ,   tokenizer=__a    ,   unet=__a    ,   scheduler=__a    ,   safety_checker=__a    ,   feature_extractor=__a    ,   )

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

							def 			snake_case				(     self	):
										self.enable_attention_slicing(__a	)

							def 			snake_case				(     self	):
										if is_accelerate_available():
													from accelerate import cpu_offload
										else:
													raise ImportError("Please install accelerate via `pip install accelerate`"	)

										__lowerCAmelCase				    =			torch.device("cuda"	)

										for cpu_offloaded_model in [self.unet, self.text_encoder, self.vae, self.safety_checker]:
													if cpu_offloaded_model is not None:
																cpu_offload(__a    ,   __a	)

							@property
							# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
							def 			snake_case				(     self	):
										if self.device != torch.device("meta"	) or not hasattr(self.unet    ,   "_hf_hook"	):
													return self.device
										for module in self.unet.modules():
													if (
													    hasattr(__a    ,   "_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()
							def __call__(     self    ,   __a    ,   __a    ,   __a    ,   __a = 5_12    ,   __a = 5_12    ,   __a = 50    ,   __a = 7.5    ,   __a = None    ,   __a = 1    ,   __a = 0.0    ,   __a = None    ,   __a = None    ,   __a = "pil"    ,   __a = True    ,   __a = None    ,   __a = 1    ,   **__a    ,   ):
										__lowerCAmelCase				    =			self.segmentation_processor(
										    text=[text]    ,   images=[image]    ,   padding="max_length"    ,   return_tensors="pt"	).to(self.device	)
										__lowerCAmelCase				    =			self.segmentation_model(**__a	)
										__lowerCAmelCase				    =			torch.sigmoid(outputs.logits	).cpu().detach().unsqueeze(-1	).numpy()
										__lowerCAmelCase				    =			self.numpy_to_pil(__a	)[0].resize(image.size	)

										# Run inpainting pipeline with the generated mask
										__lowerCAmelCase				    =			StableDiffusionInpaintPipeline(
										    vae=self.vae    ,   text_encoder=self.text_encoder    ,   tokenizer=self.tokenizer    ,   unet=self.unet    ,   scheduler=self.scheduler    ,   safety_checker=self.safety_checker    ,   feature_extractor=self.feature_extractor    ,   )
										return inpainting_pipeline(
										    prompt=__a    ,   image=__a    ,   mask_image=__a    ,   height=__a    ,   width=__a    ,   num_inference_steps=__a    ,   guidance_scale=__a    ,   negative_prompt=__a    ,   num_images_per_prompt=__a    ,   eta=__a    ,   generator=__a    ,   latents=__a    ,   output_type=__a    ,   return_dict=__a    ,   callback=__a    ,   callback_steps=__a    ,   )








"""simple docstring"""


def _lowerCamelCase	(		):

			'''simple docstring'''




			__lowerCAmelCase				    =			[]
			__lowerCAmelCase				    =			1

			while len(_UpperCamelCase      ) < 1e6:
						constant.append(str(_UpperCamelCase      )      )
						i += 1

			__lowerCAmelCase				    =			"".join(_UpperCamelCase      )

			return (
			    int(constant[0]      )
			    * int(constant[9]      )
			    * int(constant[99]      )
			    * int(constant[999]      )
			    * int(constant[9999]      )
			    * int(constant[9_9999]      )
			    * int(constant[99_9999]      )
			)


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




