


'''simple docstring'''


import gc
import random
import tempfile
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    ControlNetModel,
    DDIMScheduler,
    StableDiffusionControlNetInpaintPipeline,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet import MultiControlNetModel
from diffusers.utils import floats_tensor, load_image, load_numpy, randn_tensor, slow, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_INPAINTING_PARAMS,
    TEXT_TO_IMAGE_IMAGE_PARAMS,
)
from ..test_pipelines_common import (
    PipelineKarrasSchedulerTesterMixin,
    PipelineLatentTesterMixin,
    PipelineTesterMixin,
)


enable_full_determinism()





class    lowercase__  (						A__					,					A__					,					A__					,					unittest.TestCase ):





							'''simple docstring'''


							A_							:				Tuple				     =  StableDiffusionControlNetInpaintPipeline
							A_							:				Optional[int]				     =  TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
							A_							:				Dict				     =  TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
							A_							:				Any				     =  frozenset({"""control_image"""} )  # skip `image` and `mask` for now, only test for control_image
							A_							:				Union[str, Any]				     =  TEXT_TO_IMAGE_IMAGE_PARAMS






							def UpperCAmelCase_     (   self  ):
											torch.manual_seed(0  )
											_SCREAMING_SNAKE_CASE			:	str							=				UNetaDConditionModel(
											    block_out_channels=(32, 64)   , layers_per_block=2   , sample_size=32   , in_channels=9   , out_channels=4   , down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")   , up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")   , cross_attention_dim=32   , )
											torch.manual_seed(0  )
											_SCREAMING_SNAKE_CASE			:	List[str]							=				ControlNetModel(
											    block_out_channels=(32, 64)   , layers_per_block=2   , in_channels=4   , down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")   , cross_attention_dim=32   , conditioning_embedding_out_channels=(16, 32)   , )
											torch.manual_seed(0  )
											_SCREAMING_SNAKE_CASE			:	Dict							=				DDIMScheduler(
											    beta_start=0.00085   , beta_end=0.012   , beta_schedule="""scaled_linear"""   , clip_sample=__snake_case   , set_alpha_to_one=__snake_case   , )
											torch.manual_seed(0  )
											_SCREAMING_SNAKE_CASE			:	List[Any]							=				AutoencoderKL(
											    block_out_channels=[32, 64]   , in_channels=3   , out_channels=3   , down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]   , up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]   , latent_channels=4   , )
											torch.manual_seed(0  )
											_SCREAMING_SNAKE_CASE			:	Any							=				CLIPTextConfig(
											    bos_token_id=0   , eos_token_id=2   , hidden_size=32   , intermediate_size=37   , layer_norm_eps=1e-05   , num_attention_heads=4   , num_hidden_layers=5   , pad_token_id=1   , vocab_size=1000   , )
											_SCREAMING_SNAKE_CASE			:	List[Any]							=				CLIPTextModel(__snake_case  )
											_SCREAMING_SNAKE_CASE			:	List[str]							=				CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""  )

											_SCREAMING_SNAKE_CASE			:	Dict							=				{
											    '''unet''': unet,
											    '''controlnet''': controlnet,
											    '''scheduler''': scheduler,
											    '''vae''': vae,
											    '''text_encoder''': text_encoder,
											    '''tokenizer''': tokenizer,
											    '''safety_checker''': None,
											    '''feature_extractor''': None,
											}
											return components






							def UpperCAmelCase_     (   self   , __snake_case   , __snake_case=0  ):
											if str(__snake_case  ).startswith("""mps"""  ):
															_SCREAMING_SNAKE_CASE			:	str							=				torch.manual_seed(__snake_case  )
											else:
															_SCREAMING_SNAKE_CASE			:	List[str]							=				torch.Generator(device=__snake_case  ).manual_seed(__snake_case  )

											_SCREAMING_SNAKE_CASE			:	Optional[int]							=				2
											_SCREAMING_SNAKE_CASE			:	Optional[int]							=				randn_tensor(
											    (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)   , generator=__snake_case   , device=torch.device(__snake_case  )   , )
											_SCREAMING_SNAKE_CASE			:	Any							=				floats_tensor((1, 3, 32, 32)   , rng=random.Random(__snake_case  )  ).to(__snake_case  )
											_SCREAMING_SNAKE_CASE			:	Dict							=				init_image.cpu().permute(0   , 2   , 3   , 1  )[0]

											_SCREAMING_SNAKE_CASE			:	List[str]							=				Image.fromarray(np.uinta(__snake_case  )  ).convert("""RGB"""  ).resize((64, 64)  )
											_SCREAMING_SNAKE_CASE			:	str							=				Image.fromarray(np.uinta(init_image + 4  )  ).convert("""RGB"""  ).resize((64, 64)  )

											_SCREAMING_SNAKE_CASE			:	Dict							=				{
											    '''prompt''': '''A painting of a squirrel eating a burger''',
											    '''generator''': generator,
											    '''num_inference_steps''': 2,
											    '''guidance_scale''': 6.0,
											    '''output_type''': '''numpy''',
											    '''image''': image,
											    '''mask_image''': mask_image,
											    '''control_image''': control_image,
											}

											return inputs






							def UpperCAmelCase_     (   self  ):
											return self._test_attention_slicing_forward_pass(expected_max_diff=2e-3  )






							@unittest.skipIf(
							    torch_device != """cuda""" or not is_xformers_available()   , reason="""XFormers attention is only available with CUDA and `xformers` installed"""   , )
							def UpperCAmelCase_     (   self  ):
											self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3  )






							def UpperCAmelCase_     (   self  ):
											self._test_inference_batch_single_identical(expected_max_diff=2e-3  )





class    lowercase__  (						A__ ):





							'''simple docstring'''


							A_							:				List[str]				     =  StableDiffusionControlNetInpaintPipeline
							A_							:				Dict				     =  TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
							A_							:				Optional[Any]				     =  TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
							A_							:				Optional[Any]				     =  frozenset([] )






							def UpperCAmelCase_     (   self  ):
											torch.manual_seed(0  )
											_SCREAMING_SNAKE_CASE			:	Dict							=				UNetaDConditionModel(
											    block_out_channels=(32, 64)   , layers_per_block=2   , sample_size=32   , in_channels=4   , out_channels=4   , down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")   , up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")   , cross_attention_dim=32   , )
											torch.manual_seed(0  )
											_SCREAMING_SNAKE_CASE			:	Optional[int]							=				ControlNetModel(
											    block_out_channels=(32, 64)   , layers_per_block=2   , in_channels=4   , down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")   , cross_attention_dim=32   , conditioning_embedding_out_channels=(16, 32)   , )
											torch.manual_seed(0  )
											_SCREAMING_SNAKE_CASE			:	str							=				DDIMScheduler(
											    beta_start=0.00085   , beta_end=0.012   , beta_schedule="""scaled_linear"""   , clip_sample=__snake_case   , set_alpha_to_one=__snake_case   , )
											torch.manual_seed(0  )
											_SCREAMING_SNAKE_CASE			:	Tuple							=				AutoencoderKL(
											    block_out_channels=[32, 64]   , in_channels=3   , out_channels=3   , down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]   , up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]   , latent_channels=4   , )
											torch.manual_seed(0  )
											_SCREAMING_SNAKE_CASE			:	Optional[int]							=				CLIPTextConfig(
											    bos_token_id=0   , eos_token_id=2   , hidden_size=32   , intermediate_size=37   , layer_norm_eps=1e-05   , num_attention_heads=4   , num_hidden_layers=5   , pad_token_id=1   , vocab_size=1000   , )
											_SCREAMING_SNAKE_CASE			:	Tuple							=				CLIPTextModel(__snake_case  )
											_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""  )

											_SCREAMING_SNAKE_CASE			:	str							=				{
											    '''unet''': unet,
											    '''controlnet''': controlnet,
											    '''scheduler''': scheduler,
											    '''vae''': vae,
											    '''text_encoder''': text_encoder,
											    '''tokenizer''': tokenizer,
											    '''safety_checker''': None,
											    '''feature_extractor''': None,
											}
											return components





class    lowercase__  (						A__					,					A__					,					unittest.TestCase ):





							'''simple docstring'''


							A_							:				Dict				     =  StableDiffusionControlNetInpaintPipeline
							A_							:				Optional[int]				     =  TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
							A_							:				str				     =  TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS






							def UpperCAmelCase_     (   self  ):
											torch.manual_seed(0  )
											_SCREAMING_SNAKE_CASE			:	Dict							=				UNetaDConditionModel(
											    block_out_channels=(32, 64)   , layers_per_block=2   , sample_size=32   , in_channels=9   , out_channels=4   , down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")   , up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")   , cross_attention_dim=32   , )
											torch.manual_seed(0  )

											def init_weights(__snake_case  ):
															if isinstance(__snake_case   , torch.nn.Convad  ):
																			torch.nn.init.normal(m.weight  )
																			m.bias.data.fill_(1.0  )

											_SCREAMING_SNAKE_CASE			:	Tuple							=				ControlNetModel(
											    block_out_channels=(32, 64)   , layers_per_block=2   , in_channels=4   , down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")   , cross_attention_dim=32   , conditioning_embedding_out_channels=(16, 32)   , )
											controlneta.controlnet_down_blocks.apply(__snake_case  )

											torch.manual_seed(0  )
											_SCREAMING_SNAKE_CASE			:	Optional[Any]							=				ControlNetModel(
											    block_out_channels=(32, 64)   , layers_per_block=2   , in_channels=4   , down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")   , cross_attention_dim=32   , conditioning_embedding_out_channels=(16, 32)   , )
											controlneta.controlnet_down_blocks.apply(__snake_case  )

											torch.manual_seed(0  )
											_SCREAMING_SNAKE_CASE			:	Optional[Any]							=				DDIMScheduler(
											    beta_start=0.00085   , beta_end=0.012   , beta_schedule="""scaled_linear"""   , clip_sample=__snake_case   , set_alpha_to_one=__snake_case   , )
											torch.manual_seed(0  )
											_SCREAMING_SNAKE_CASE			:	Any							=				AutoencoderKL(
											    block_out_channels=[32, 64]   , in_channels=3   , out_channels=3   , down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]   , up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]   , latent_channels=4   , )
											torch.manual_seed(0  )
											_SCREAMING_SNAKE_CASE			:	str							=				CLIPTextConfig(
											    bos_token_id=0   , eos_token_id=2   , hidden_size=32   , intermediate_size=37   , layer_norm_eps=1e-05   , num_attention_heads=4   , num_hidden_layers=5   , pad_token_id=1   , vocab_size=1000   , )
											_SCREAMING_SNAKE_CASE			:	List[Any]							=				CLIPTextModel(__snake_case  )
											_SCREAMING_SNAKE_CASE			:	int							=				CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""  )

											_SCREAMING_SNAKE_CASE			:	Any							=				MultiControlNetModel([controlneta, controlneta]  )

											_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				{
											    '''unet''': unet,
											    '''controlnet''': controlnet,
											    '''scheduler''': scheduler,
											    '''vae''': vae,
											    '''text_encoder''': text_encoder,
											    '''tokenizer''': tokenizer,
											    '''safety_checker''': None,
											    '''feature_extractor''': None,
											}
											return components






							def UpperCAmelCase_     (   self   , __snake_case   , __snake_case=0  ):
											if str(__snake_case  ).startswith("""mps"""  ):
															_SCREAMING_SNAKE_CASE			:	Any							=				torch.manual_seed(__snake_case  )
											else:
															_SCREAMING_SNAKE_CASE			:	Optional[Any]							=				torch.Generator(device=__snake_case  ).manual_seed(__snake_case  )

											_SCREAMING_SNAKE_CASE			:	Any							=				2

											_SCREAMING_SNAKE_CASE			:	Optional[Any]							=				[
											    randn_tensor(
											        (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)   , generator=__snake_case   , device=torch.device(__snake_case  )   , ),
											    randn_tensor(
											        (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)   , generator=__snake_case   , device=torch.device(__snake_case  )   , ),
											]
											_SCREAMING_SNAKE_CASE			:	Optional[Any]							=				floats_tensor((1, 3, 32, 32)   , rng=random.Random(__snake_case  )  ).to(__snake_case  )
											_SCREAMING_SNAKE_CASE			:	Optional[Any]							=				init_image.cpu().permute(0   , 2   , 3   , 1  )[0]

											_SCREAMING_SNAKE_CASE			:	Dict							=				Image.fromarray(np.uinta(__snake_case  )  ).convert("""RGB"""  ).resize((64, 64)  )
											_SCREAMING_SNAKE_CASE			:	Optional[Any]							=				Image.fromarray(np.uinta(init_image + 4  )  ).convert("""RGB"""  ).resize((64, 64)  )

											_SCREAMING_SNAKE_CASE			:	Any							=				{
											    '''prompt''': '''A painting of a squirrel eating a burger''',
											    '''generator''': generator,
											    '''num_inference_steps''': 2,
											    '''guidance_scale''': 6.0,
											    '''output_type''': '''numpy''',
											    '''image''': image,
											    '''mask_image''': mask_image,
											    '''control_image''': control_image,
											}

											return inputs






							def UpperCAmelCase_     (   self  ):
											_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				self.get_dummy_components()
											_SCREAMING_SNAKE_CASE			:	List[str]							=				self.pipeline_class(**__snake_case  )
											pipe.to(__snake_case  )

											_SCREAMING_SNAKE_CASE			:	Tuple							=				10.0
											_SCREAMING_SNAKE_CASE			:	List[Any]							=				4

											_SCREAMING_SNAKE_CASE			:	Dict							=				self.get_dummy_inputs(__snake_case  )
											_SCREAMING_SNAKE_CASE			:	str							=				steps
											_SCREAMING_SNAKE_CASE			:	Tuple							=				scale
											_SCREAMING_SNAKE_CASE			:	Optional[Any]							=				pipe(**__snake_case  )[0]

											_SCREAMING_SNAKE_CASE			:	List[str]							=				self.get_dummy_inputs(__snake_case  )
											_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				steps
											_SCREAMING_SNAKE_CASE			:	Dict							=				scale
											_SCREAMING_SNAKE_CASE			:	Any							=				pipe(**__snake_case   , control_guidance_start=0.1   , control_guidance_end=0.2  )[0]

											_SCREAMING_SNAKE_CASE			:	Optional[Any]							=				self.get_dummy_inputs(__snake_case  )
											_SCREAMING_SNAKE_CASE			:	Optional[int]							=				steps
											_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				scale
											_SCREAMING_SNAKE_CASE			:	Optional[Any]							=				pipe(**__snake_case   , control_guidance_start=[0.1, 0.3]   , control_guidance_end=[0.2, 0.7]  )[0]

											_SCREAMING_SNAKE_CASE			:	Optional[Any]							=				self.get_dummy_inputs(__snake_case  )
											_SCREAMING_SNAKE_CASE			:	int							=				steps
											_SCREAMING_SNAKE_CASE			:	str							=				scale
											_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				pipe(**__snake_case   , control_guidance_start=0.4   , control_guidance_end=[0.5, 0.8]  )[0]

											# make sure that all outputs are different
											assert np.sum(np.abs(output_a - output_a  )  ) > 1e-3
											assert np.sum(np.abs(output_a - output_a  )  ) > 1e-3
											assert np.sum(np.abs(output_a - output_a  )  ) > 1e-3






							def UpperCAmelCase_     (   self  ):
											return self._test_attention_slicing_forward_pass(expected_max_diff=2e-3  )






							@unittest.skipIf(
							    torch_device != """cuda""" or not is_xformers_available()   , reason="""XFormers attention is only available with CUDA and `xformers` installed"""   , )
							def UpperCAmelCase_     (   self  ):
											self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3  )






							def UpperCAmelCase_     (   self  ):
											self._test_inference_batch_single_identical(expected_max_diff=2e-3  )






							def UpperCAmelCase_     (   self  ):
											_SCREAMING_SNAKE_CASE			:	Tuple							=				self.get_dummy_components()
											_SCREAMING_SNAKE_CASE			:	List[str]							=				self.pipeline_class(**__snake_case  )
											pipe.to(__snake_case  )
											pipe.set_progress_bar_config(disable=__snake_case  )
											with tempfile.TemporaryDirectory() as tmpdir:
															try:
																			# save_pretrained is not implemented for Multi-ControlNet
																			pipe.save_pretrained(__snake_case  )
															except NotImplementedError:
																			pass





@slow
@require_torch_gpu
class    lowercase__  (						unittest.TestCase ):





							'''simple docstring'''


							def UpperCAmelCase_     (   self  ):
											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()






							def UpperCAmelCase_     (   self  ):
											_SCREAMING_SNAKE_CASE			:	List[str]							=				ControlNetModel.from_pretrained("""lllyasviel/sd-controlnet-canny"""  )

											_SCREAMING_SNAKE_CASE			:	List[str]							=				StableDiffusionControlNetInpaintPipeline.from_pretrained(
											    """runwayml/stable-diffusion-inpainting"""   , safety_checker=__snake_case   , controlnet=__snake_case  )
											pipe.enable_model_cpu_offload()
											pipe.set_progress_bar_config(disable=__snake_case  )

											_SCREAMING_SNAKE_CASE			:	Optional[int]							=				torch.Generator(device="""cpu"""  ).manual_seed(0  )
											_SCREAMING_SNAKE_CASE			:	str							=				load_image(
											    """https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png"""  ).resize((512, 512)  )

											_SCREAMING_SNAKE_CASE			:	List[str]							=				load_image(
											    """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"""
											    """/stable_diffusion_inpaint/input_bench_mask.png"""  ).resize((512, 512)  )

											_SCREAMING_SNAKE_CASE			:	List[Any]							=				'''pitch black hole'''

											_SCREAMING_SNAKE_CASE			:	Any							=				load_image(
											    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png"""  ).resize((512, 512)  )

											_SCREAMING_SNAKE_CASE			:	List[Any]							=				pipe(
											    __snake_case   , image=__snake_case   , mask_image=__snake_case   , control_image=__snake_case   , generator=__snake_case   , output_type="""np"""   , num_inference_steps=3   , )

											_SCREAMING_SNAKE_CASE			:	int							=				output.images[0]

											assert image.shape == (512, 512, 3)

											_SCREAMING_SNAKE_CASE			:	int							=				load_numpy(
											    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/inpaint.npy"""  )

											assert np.abs(expected_image - image  ).max() < 9e-2






							def UpperCAmelCase_     (   self  ):
											_SCREAMING_SNAKE_CASE			:	Optional[int]							=				ControlNetModel.from_pretrained("""lllyasviel/control_v11p_sd15_inpaint"""  )

											_SCREAMING_SNAKE_CASE			:	List[Any]							=				StableDiffusionControlNetInpaintPipeline.from_pretrained(
											    """runwayml/stable-diffusion-v1-5"""   , safety_checker=__snake_case   , controlnet=__snake_case  )
											_SCREAMING_SNAKE_CASE			:	str							=				DDIMScheduler.from_config(pipe.scheduler.config  )
											pipe.enable_model_cpu_offload()
											pipe.set_progress_bar_config(disable=__snake_case  )

											_SCREAMING_SNAKE_CASE			:	List[Any]							=				torch.Generator(device="""cpu"""  ).manual_seed(33  )

											_SCREAMING_SNAKE_CASE			:	Tuple							=				load_image(
											    """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy.png"""  )
											_SCREAMING_SNAKE_CASE			:	Dict							=				init_image.resize((512, 512)  )

											_SCREAMING_SNAKE_CASE			:	str							=				load_image(
											    """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy_mask.png"""  )
											_SCREAMING_SNAKE_CASE			:	str							=				mask_image.resize((512, 512)  )

											_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				'''a handsome man with ray-ban sunglasses'''

											def make_inpaint_condition(__snake_case   , __snake_case  ):
															_SCREAMING_SNAKE_CASE			:	int							=				np.array(image.convert("""RGB"""  )  ).astype(np.floataa  ) / 255.0
															_SCREAMING_SNAKE_CASE			:	Tuple							=				np.array(image_mask.convert("""L"""  )  ).astype(np.floataa  ) / 255.0

															assert image.shape[0:1] == image_mask.shape[0:1], "image and image_mask must have the same image size"
															_SCREAMING_SNAKE_CASE			:	int							=				-1.0  # set as masked pixel
															_SCREAMING_SNAKE_CASE			:	Any							=				np.expand_dims(__snake_case   , 0  ).transpose(0   , 3   , 1   , 2  )
															_SCREAMING_SNAKE_CASE			:	List[Any]							=				torch.from_numpy(__snake_case  )
															return image

											_SCREAMING_SNAKE_CASE			:	List[Any]							=				make_inpaint_condition(__snake_case   , __snake_case  )

											_SCREAMING_SNAKE_CASE			:	Any							=				pipe(
											    __snake_case   , image=__snake_case   , mask_image=__snake_case   , control_image=__snake_case   , guidance_scale=9.0   , eta=1.0   , generator=__snake_case   , num_inference_steps=20   , output_type="""np"""   , )
											_SCREAMING_SNAKE_CASE			:	List[str]							=				output.images[0]

											assert image.shape == (512, 512, 3)

											_SCREAMING_SNAKE_CASE			:	Optional[int]							=				load_numpy(
											    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/boy_ray_ban.npy"""  )

											assert np.abs(expected_image - image  ).max() < 9e-2








'''simple docstring'''


def       snake_case_       (  SCREAMING_SNAKE_CASE__ = 1000					):







				"""simple docstring"""





				_SCREAMING_SNAKE_CASE			:	Union[str, Any]							=				[0, 3, 3, 5, 4, 4, 3, 5, 5, 4, 3, 6, 6, 8, 8, 7, 7, 9, 8, 8]
				# number of letters in twenty, thirty, ..., ninety (0 for numbers less than
				# 20 due to inconsistency in teens)
				_SCREAMING_SNAKE_CASE			:	str							=				[0, 0, 6, 6, 5, 5, 5, 7, 6, 6]

				_SCREAMING_SNAKE_CASE			:	Any							=				0

				for i in range(1							,				n + 1					):
								if i < 1000:
												if i >= 100:
																# add number of letters for "n hundred"
																count += ones_counts[i // 100] + 7

																if i % 100 != 0:
																				# add number of letters for "and" if number is not multiple
																				# of 100
																				count += 3

												if 0 < i % 100 < 20:
																# add number of letters for one, two, three, ..., nineteen
																# (could be combined with below if not for inconsistency in
																# teens)
																count += ones_counts[i % 100]
												else:
																# add number of letters for twenty, twenty one, ..., ninety
																# nine
																count += ones_counts[i % 10]
																count += tens_counts[(i % 100 - i % 10) // 10]
								else:
												count += ones_counts[i // 1000] + 8
				return count


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




