


# This model implementation is heavily based on:

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      __snake_case				(   _UpperCAmelCase	,      _UpperCAmelCase	,      _UpperCAmelCase	,      unittest.TestCase):
					SCREAMING_SNAKE_CASE_		:       Optional[Any]								=			StableDiffusionControlNetInpaintPipeline
					SCREAMING_SNAKE_CASE_		:       Any								=			TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
					SCREAMING_SNAKE_CASE_		:       int								=			TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
					SCREAMING_SNAKE_CASE_		:       Optional[Any]								=			frozenset({"control_image"})  # skip `image` and `mask` for now, only test for control_image
					SCREAMING_SNAKE_CASE_		:       Union[str, Any]								=			TEXT_TO_IMAGE_IMAGE_PARAMS
					def 	a			(						self       :						int  )							->					Union[str, Any]:



											'''simple docstring'''





											torch.manual_seed(0  )
											__magic_name__					=      UNetaDConditionModel(
											    block_out_channels=(3_2, 6_4)	,      layers_per_block=2	,      sample_size=3_2	,      in_channels=9	,      out_channels=4	,      down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')	,      up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')	,      cross_attention_dim=3_2	,      )
											torch.manual_seed(0  )
											__magic_name__					=      ControlNetModel(
											    block_out_channels=(3_2, 6_4)	,      layers_per_block=2	,      in_channels=4	,      down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')	,      cross_attention_dim=3_2	,      conditioning_embedding_out_channels=(1_6, 3_2)	,      )
											torch.manual_seed(0  )
											__magic_name__					=      DDIMScheduler(
											    beta_start=0.0_0085	,      beta_end=0.012	,      beta_schedule='scaled_linear'	,      clip_sample=_lowerCAmelCase	,      set_alpha_to_one=_lowerCAmelCase	,      )
											torch.manual_seed(0  )
											__magic_name__					=      AutoencoderKL(
											    block_out_channels=[3_2, 6_4]	,      in_channels=3	,      out_channels=3	,      down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']	,      up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']	,      latent_channels=4	,      )
											torch.manual_seed(0  )
											__magic_name__					=      CLIPTextConfig(
											    bos_token_id=0	,      eos_token_id=2	,      hidden_size=3_2	,      intermediate_size=3_7	,      layer_norm_eps=1E-0_5	,      num_attention_heads=4	,      num_hidden_layers=5	,      pad_token_id=1	,      vocab_size=1_0_0_0	,      )
											__magic_name__					=      CLIPTextModel(_lowerCAmelCase  )
											__magic_name__					=      CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'  )

											__magic_name__					=      {
											    'unet': unet,
											    'controlnet': controlnet,
											    'scheduler': scheduler,
											    'vae': vae,
											    'text_encoder': text_encoder,
											    'tokenizer': tokenizer,
											    'safety_checker': None,
											    'feature_extractor': None,
											}
											return components
					def 	a			(						self       :						Tuple	,      _lowerCAmelCase       :						str	,      _lowerCAmelCase       :						int=0  )							->					Tuple:



											'''simple docstring'''





											if str(_lowerCAmelCase  ).startswith('mps'  ):
																	__magic_name__					=      torch.manual_seed(_lowerCAmelCase  )
											else:
																	__magic_name__					=      torch.Generator(device=_lowerCAmelCase  ).manual_seed(_lowerCAmelCase  )

											__magic_name__					=      2
											__magic_name__					=      randn_tensor(
											    (1, 3, 3_2 * controlnet_embedder_scale_factor, 3_2 * controlnet_embedder_scale_factor)	,      generator=_lowerCAmelCase	,      device=torch.device(_lowerCAmelCase  )	,      )
											__magic_name__					=      floats_tensor((1, 3, 3_2, 3_2)	,      rng=random.Random(_lowerCAmelCase  )  ).to(_lowerCAmelCase  )
											__magic_name__					=      init_image.cpu().permute(0	,      2	,      3	,      1  )[0]

											__magic_name__					=      Image.fromarray(np.uinta(_lowerCAmelCase  )  ).convert('RGB'  ).resize((6_4, 6_4)  )
											__magic_name__					=      Image.fromarray(np.uinta(init_image + 4  )  ).convert('RGB'  ).resize((6_4, 6_4)  )

											__magic_name__					=      {
											    '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 	a			(						self       :						int  )							->					str:



											'''simple docstring'''





											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 	a			(						self       :						str  )							->					Optional[int]:



											'''simple docstring'''





											self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3  )







					def 	a			(						self       :						List[Any]  )							->					Optional[Any]:



											'''simple docstring'''





											self._test_inference_batch_single_identical(expected_max_diff=2E-3  )







class      __snake_case				(   _UpperCAmelCase):
					SCREAMING_SNAKE_CASE_		:       int								=			StableDiffusionControlNetInpaintPipeline
					SCREAMING_SNAKE_CASE_		:       str								=			TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
					SCREAMING_SNAKE_CASE_		:       Optional[Any]								=			TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
					SCREAMING_SNAKE_CASE_		:       List[str]								=			frozenset([])
					def 	a			(						self       :						Dict  )							->					Tuple:



											'''simple docstring'''





											torch.manual_seed(0  )
											__magic_name__					=      UNetaDConditionModel(
											    block_out_channels=(3_2, 6_4)	,      layers_per_block=2	,      sample_size=3_2	,      in_channels=4	,      out_channels=4	,      down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')	,      up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')	,      cross_attention_dim=3_2	,      )
											torch.manual_seed(0  )
											__magic_name__					=      ControlNetModel(
											    block_out_channels=(3_2, 6_4)	,      layers_per_block=2	,      in_channels=4	,      down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')	,      cross_attention_dim=3_2	,      conditioning_embedding_out_channels=(1_6, 3_2)	,      )
											torch.manual_seed(0  )
											__magic_name__					=      DDIMScheduler(
											    beta_start=0.0_0085	,      beta_end=0.012	,      beta_schedule='scaled_linear'	,      clip_sample=_lowerCAmelCase	,      set_alpha_to_one=_lowerCAmelCase	,      )
											torch.manual_seed(0  )
											__magic_name__					=      AutoencoderKL(
											    block_out_channels=[3_2, 6_4]	,      in_channels=3	,      out_channels=3	,      down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']	,      up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']	,      latent_channels=4	,      )
											torch.manual_seed(0  )
											__magic_name__					=      CLIPTextConfig(
											    bos_token_id=0	,      eos_token_id=2	,      hidden_size=3_2	,      intermediate_size=3_7	,      layer_norm_eps=1E-0_5	,      num_attention_heads=4	,      num_hidden_layers=5	,      pad_token_id=1	,      vocab_size=1_0_0_0	,      )
											__magic_name__					=      CLIPTextModel(_lowerCAmelCase  )
											__magic_name__					=      CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'  )

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







class      __snake_case				(   _UpperCAmelCase	,      _UpperCAmelCase	,      unittest.TestCase):
					SCREAMING_SNAKE_CASE_		:       List[Any]								=			StableDiffusionControlNetInpaintPipeline
					SCREAMING_SNAKE_CASE_		:       str								=			TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
					SCREAMING_SNAKE_CASE_		:       List[Any]								=			TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
					def 	a			(						self       :						str  )							->					Dict:



											'''simple docstring'''





											torch.manual_seed(0  )
											__magic_name__					=      UNetaDConditionModel(
											    block_out_channels=(3_2, 6_4)	,      layers_per_block=2	,      sample_size=3_2	,      in_channels=9	,      out_channels=4	,      down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')	,      up_block_types=('CrossAttnUpBlock2D', 'UpBlock2D')	,      cross_attention_dim=3_2	,      )
											torch.manual_seed(0  )

											def init_weights(_lowerCAmelCase       :						List[str]  ):
																	if isinstance(_lowerCAmelCase	,      torch.nn.Convad  ):
																							torch.nn.init.normal(m.weight  )
																							m.bias.data.fill_(1.0  )

											__magic_name__					=      ControlNetModel(
											    block_out_channels=(3_2, 6_4)	,      layers_per_block=2	,      in_channels=4	,      down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')	,      cross_attention_dim=3_2	,      conditioning_embedding_out_channels=(1_6, 3_2)	,      )
											controlneta.controlnet_down_blocks.apply(_lowerCAmelCase  )

											torch.manual_seed(0  )
											__magic_name__					=      ControlNetModel(
											    block_out_channels=(3_2, 6_4)	,      layers_per_block=2	,      in_channels=4	,      down_block_types=('DownBlock2D', 'CrossAttnDownBlock2D')	,      cross_attention_dim=3_2	,      conditioning_embedding_out_channels=(1_6, 3_2)	,      )
											controlneta.controlnet_down_blocks.apply(_lowerCAmelCase  )

											torch.manual_seed(0  )
											__magic_name__					=      DDIMScheduler(
											    beta_start=0.0_0085	,      beta_end=0.012	,      beta_schedule='scaled_linear'	,      clip_sample=_lowerCAmelCase	,      set_alpha_to_one=_lowerCAmelCase	,      )
											torch.manual_seed(0  )
											__magic_name__					=      AutoencoderKL(
											    block_out_channels=[3_2, 6_4]	,      in_channels=3	,      out_channels=3	,      down_block_types=['DownEncoderBlock2D', 'DownEncoderBlock2D']	,      up_block_types=['UpDecoderBlock2D', 'UpDecoderBlock2D']	,      latent_channels=4	,      )
											torch.manual_seed(0  )
											__magic_name__					=      CLIPTextConfig(
											    bos_token_id=0	,      eos_token_id=2	,      hidden_size=3_2	,      intermediate_size=3_7	,      layer_norm_eps=1E-0_5	,      num_attention_heads=4	,      num_hidden_layers=5	,      pad_token_id=1	,      vocab_size=1_0_0_0	,      )
											__magic_name__					=      CLIPTextModel(_lowerCAmelCase  )
											__magic_name__					=      CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'  )

											__magic_name__					=      MultiControlNetModel([controlneta, controlneta]  )

											__magic_name__					=      {
											    'unet': unet,
											    'controlnet': controlnet,
											    'scheduler': scheduler,
											    'vae': vae,
											    'text_encoder': text_encoder,
											    'tokenizer': tokenizer,
											    'safety_checker': None,
											    'feature_extractor': None,
											}
											return components
					def 	a			(						self       :						int	,      _lowerCAmelCase       :						Dict	,      _lowerCAmelCase       :						str=0  )							->					List[Any]:



											'''simple docstring'''





											if str(_lowerCAmelCase  ).startswith('mps'  ):
																	__magic_name__					=      torch.manual_seed(_lowerCAmelCase  )
											else:
																	__magic_name__					=      torch.Generator(device=_lowerCAmelCase  ).manual_seed(_lowerCAmelCase  )

											__magic_name__					=      2

											__magic_name__					=      [
											    randn_tensor(
											        (1, 3, 3_2 * controlnet_embedder_scale_factor, 3_2 * controlnet_embedder_scale_factor)	,      generator=_lowerCAmelCase	,      device=torch.device(_lowerCAmelCase  )	,      ),
											    randn_tensor(
											        (1, 3, 3_2 * controlnet_embedder_scale_factor, 3_2 * controlnet_embedder_scale_factor)	,      generator=_lowerCAmelCase	,      device=torch.device(_lowerCAmelCase  )	,      ),
											]
											__magic_name__					=      floats_tensor((1, 3, 3_2, 3_2)	,      rng=random.Random(_lowerCAmelCase  )  ).to(_lowerCAmelCase  )
											__magic_name__					=      init_image.cpu().permute(0	,      2	,      3	,      1  )[0]

											__magic_name__					=      Image.fromarray(np.uinta(_lowerCAmelCase  )  ).convert('RGB'  ).resize((6_4, 6_4)  )
											__magic_name__					=      Image.fromarray(np.uinta(init_image + 4  )  ).convert('RGB'  ).resize((6_4, 6_4)  )

											__magic_name__					=      {
											    '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 	a			(						self       :						List[Any]  )							->					Optional[Any]:



											'''simple docstring'''





											__magic_name__					=      self.get_dummy_components()
											__magic_name__					=      self.pipeline_class(**_lowerCAmelCase  )
											pipe.to(_lowerCAmelCase  )

											__magic_name__					=      10.0
											__magic_name__					=      4

											__magic_name__					=      self.get_dummy_inputs(_lowerCAmelCase  )
											__magic_name__					=      steps
											__magic_name__					=      scale
											__magic_name__					=      pipe(**_lowerCAmelCase  )[0]

											__magic_name__					=      self.get_dummy_inputs(_lowerCAmelCase  )
											__magic_name__					=      steps
											__magic_name__					=      scale
											__magic_name__					=      pipe(**_lowerCAmelCase	,      control_guidance_start=0.1	,      control_guidance_end=0.2  )[0]

											__magic_name__					=      self.get_dummy_inputs(_lowerCAmelCase  )
											__magic_name__					=      steps
											__magic_name__					=      scale
											__magic_name__					=      pipe(**_lowerCAmelCase	,      control_guidance_start=[0.1, 0.3]	,      control_guidance_end=[0.2, 0.7]  )[0]

											__magic_name__					=      self.get_dummy_inputs(_lowerCAmelCase  )
											__magic_name__					=      steps
											__magic_name__					=      scale
											__magic_name__					=      pipe(**_lowerCAmelCase	,      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 	a			(						self       :						Dict  )							->					List[str]:



											'''simple docstring'''





											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 	a			(						self       :						Any  )							->					Union[str, Any]:



											'''simple docstring'''





											self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2E-3  )
					def 	a			(						self       :						List[str]  )							->					Optional[Any]:



											'''simple docstring'''





											self._test_inference_batch_single_identical(expected_max_diff=2E-3  )







					def 	a			(						self       :						Union[str, Any]  )							->					Tuple:



											'''simple docstring'''





											__magic_name__					=      self.get_dummy_components()
											__magic_name__					=      self.pipeline_class(**_lowerCAmelCase  )
											pipe.to(_lowerCAmelCase  )
											pipe.set_progress_bar_config(disable=_lowerCAmelCase  )
											with tempfile.TemporaryDirectory() as tmpdir:
																	try:
																							# save_pretrained is not implemented for Multi-ControlNet
																							pipe.save_pretrained(_lowerCAmelCase  )
																	except NotImplementedError:
																							pass







@slow
@require_torch_gpu
class      __snake_case				(   unittest.TestCase):
					def 	a			(						self       :						Optional[int]  )							->					Tuple:



											'''simple docstring'''





											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()
					def 	a			(						self       :						str  )							->					Dict:



											'''simple docstring'''





											__magic_name__					=      ControlNetModel.from_pretrained('lllyasviel/sd-controlnet-canny'  )

											__magic_name__					=      StableDiffusionControlNetInpaintPipeline.from_pretrained(
											    'runwayml/stable-diffusion-inpainting'	,      safety_checker=_lowerCAmelCase	,      controlnet=_lowerCAmelCase  )
											pipe.enable_model_cpu_offload()
											pipe.set_progress_bar_config(disable=_lowerCAmelCase  )

											__magic_name__					=      torch.Generator(device='cpu'  ).manual_seed(0  )
											__magic_name__					=      load_image(
											    'https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png'  ).resize((5_1_2, 5_1_2)  )

											__magic_name__					=      load_image(
											    'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main'
											    '/stable_diffusion_inpaint/input_bench_mask.png'  ).resize((5_1_2, 5_1_2)  )

											__magic_name__					=      'pitch black hole'

											__magic_name__					=      load_image(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png'  ).resize((5_1_2, 5_1_2)  )

											__magic_name__					=      pipe(
											    _lowerCAmelCase	,      image=_lowerCAmelCase	,      mask_image=_lowerCAmelCase	,      control_image=_lowerCAmelCase	,      generator=_lowerCAmelCase	,      output_type='np'	,      num_inference_steps=3	,      )

											__magic_name__					=      output.images[0]

											assert image.shape == (5_1_2, 5_1_2, 3)

											__magic_name__					=      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 	a			(						self       :						Any  )							->					Optional[int]:



											'''simple docstring'''





											__magic_name__					=      ControlNetModel.from_pretrained('lllyasviel/control_v11p_sd15_inpaint'  )

											__magic_name__					=      StableDiffusionControlNetInpaintPipeline.from_pretrained(
											    'runwayml/stable-diffusion-v1-5'	,      safety_checker=_lowerCAmelCase	,      controlnet=_lowerCAmelCase  )
											__magic_name__					=      DDIMScheduler.from_config(pipe.scheduler.config  )
											pipe.enable_model_cpu_offload()
											pipe.set_progress_bar_config(disable=_lowerCAmelCase  )

											__magic_name__					=      torch.Generator(device='cpu'  ).manual_seed(3_3  )

											__magic_name__					=      load_image(
											    'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy.png'  )
											__magic_name__					=      init_image.resize((5_1_2, 5_1_2)  )

											__magic_name__					=      load_image(
											    'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy_mask.png'  )
											__magic_name__					=      mask_image.resize((5_1_2, 5_1_2)  )

											__magic_name__					=      'a handsome man with ray-ban sunglasses'

											def make_inpaint_condition(_lowerCAmelCase       :						int	,      _lowerCAmelCase       :						Dict  ):
																	__magic_name__					=      np.array(image.convert('RGB'  )  ).astype(np.floataa  ) / 255.0
																	__magic_name__					=      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"
																	__magic_name__					=      -1.0  # set as masked pixel
																	__magic_name__					=      np.expand_dims(_lowerCAmelCase	,      0  ).transpose(0	,      3	,      1	,      2  )
																	__magic_name__					=      torch.from_numpy(_lowerCAmelCase  )
																	return image

											__magic_name__					=      make_inpaint_condition(_lowerCAmelCase	,      _lowerCAmelCase  )

											__magic_name__					=      pipe(
											    _lowerCAmelCase	,      image=_lowerCAmelCase	,      mask_image=_lowerCAmelCase	,      control_image=_lowerCAmelCase	,      guidance_scale=9.0	,      eta=1.0	,      generator=_lowerCAmelCase	,      num_inference_steps=2_0	,      output_type='np'	,      )
											__magic_name__					=      output.images[0]

											assert image.shape == (5_1_2, 5_1_2, 3)

											__magic_name__					=      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





from itertools import count
from math import asin, pi, sqrt
def 				UpperCamelCase_	(					__snake_case      :    float  )->   float:




						'''simple docstring'''
						return (
						    (1 - 2 * point) * sqrt(point - point**2  ) + 2 * point + asin(sqrt(1 - point  )  )
						) / 4
def 				UpperCamelCase_	(					__snake_case      :    int  )->   float:




						'''simple docstring'''
						__magic_name__					=      (circles_number + 1 - sqrt(2 * circles_number  )) / (
						    2 * (circles_number**2 + 1)
						)
						__magic_name__					=      circles_number * intersection_y

						__magic_name__					=      intersection_x * intersection_y / 2
						__magic_name__					=      circle_bottom_arc_integral(
						    1 / 2  ) - circle_bottom_arc_integral(__snake_case  )

						return triangle_area + concave_region_area
def 				UpperCamelCase_	(					__snake_case      :    float = 1 / 10_00  )->   int:




						'''simple docstring'''
						__magic_name__					=      (1 - pi / 4) / 4

						for n in count(1  ):
												if concave_triangle_area(__snake_case  ) / l_section_area < fraction:
																		return n

						return -1


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

