code: 
  
  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     lowerCamelCase_			(  UpperCAmelCase_	,			UpperCAmelCase_	,			UpperCAmelCase_	,			unittest.TestCase  ):
  	_lowercase		:      Tuple    				=							StableDiffusionControlNetInpaintPipeline
  	_lowercase		:      List[Any]    				=							TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
  	_lowercase		:      Any    				=							TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
  	_lowercase		:      Optional[Any]    				=							frozenset({'''control_image'''}  )  # skip `image` and `mask` for now, only test for control_image
  	_lowercase		:      Tuple    				=							TEXT_TO_IMAGE_IMAGE_PARAMS
  
  
  
  
  	def 					lowerCAmelCase_					(				self	:    Any       ):
  		torch.manual_seed(0       )
  		__A   : int								= 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       )
  		__A   : 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       )
  		__A   : Dict								= DDIMScheduler(
  		    beta_start=0.0_0_0_8_5				,			beta_end=0.0_1_2				,			beta_schedule="""scaled_linear"""				,			clip_sample=__UpperCamelCase				,			set_alpha_to_one=__UpperCamelCase				,			)
  		torch.manual_seed(0       )
  		__A   : int								= 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       )
  		__A   : Dict								= CLIPTextConfig(
  		    bos_token_id=0				,			eos_token_id=2				,			hidden_size=32				,			intermediate_size=37				,			layer_norm_eps=1e-0_5				,			num_attention_heads=4				,			num_hidden_layers=5				,			pad_token_id=1				,			vocab_size=1000				,			)
  		__A   : Tuple								= CLIPTextModel(__UpperCamelCase       )
  		__A   : Union[str, Any]								= CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""       )
  
  		__A   : Optional[int]								= {
  		    """unet""": unet,
  		    """controlnet""": controlnet,
  		    """scheduler""": scheduler,
  		    """vae""": vae,
  		    """text_encoder""": text_encoder,
  		    """tokenizer""": tokenizer,
  		    """safety_checker""": None,
  		    """feature_extractor""": None,
  		}
  		return components
  
  
  
  
  	def 					lowerCAmelCase_					(				self	:    List[str]				,			__A	:    Optional[Any]				,			__A	:    Optional[Any]=0       ):
  		if str(__UpperCamelCase       ).startswith("""mps"""       ):
  			__A   : str								= torch.manual_seed(__UpperCamelCase       )
  		else:
  			__A   : Any								= torch.Generator(device=__UpperCamelCase       ).manual_seed(__UpperCamelCase       )
  
  		__A   : Dict								= 2
  		__A   : Union[str, Any]								= randn_tensor(
  		    (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)				,			generator=__UpperCamelCase				,			device=torch.device(__UpperCamelCase       )				,			)
  		__A   : Union[str, Any]								= floats_tensor((1, 3, 32, 32)				,			rng=random.Random(__UpperCamelCase       )       ).to(__UpperCamelCase       )
  		__A   : List[str]								= init_image.cpu().permute(0				,			2				,			3				,			1       )[0]
  
  		__A   : Any								= Image.fromarray(np.uinta(__UpperCamelCase       )       ).convert("""RGB"""       ).resize((64, 64)       )
  		__A   : Any								= Image.fromarray(np.uinta(init_image + 4       )       ).convert("""RGB"""       ).resize((64, 64)       )
  
  		__A   : int								= {
  		    """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 					lowerCAmelCase_					(				self	:    List[Any]       ):
  		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 					lowerCAmelCase_					(				self	:    int       ):
  		self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3       )
  
  
  
  
  	def 					lowerCAmelCase_					(				self	:    Optional[int]       ):
  		self._test_inference_batch_single_identical(expected_max_diff=2e-3       )
  
  
  
  
  
  
  class     lowerCamelCase_			(  UpperCAmelCase_  ):
  	_lowercase		:      List[str]    				=							StableDiffusionControlNetInpaintPipeline
  	_lowercase		:      Dict    				=							TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
  	_lowercase		:      Tuple    				=							TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
  	_lowercase		:      Optional[Any]    				=							frozenset([]  )
  
  
  
  
  	def 					lowerCAmelCase_					(				self	:    List[Any]       ):
  		torch.manual_seed(0       )
  		__A   : str								= 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       )
  		__A   : Dict								= 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       )
  		__A   : Tuple								= DDIMScheduler(
  		    beta_start=0.0_0_0_8_5				,			beta_end=0.0_1_2				,			beta_schedule="""scaled_linear"""				,			clip_sample=__UpperCamelCase				,			set_alpha_to_one=__UpperCamelCase				,			)
  		torch.manual_seed(0       )
  		__A   : str								= 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       )
  		__A   : Tuple								= CLIPTextConfig(
  		    bos_token_id=0				,			eos_token_id=2				,			hidden_size=32				,			intermediate_size=37				,			layer_norm_eps=1e-0_5				,			num_attention_heads=4				,			num_hidden_layers=5				,			pad_token_id=1				,			vocab_size=1000				,			)
  		__A   : List[str]								= CLIPTextModel(__UpperCamelCase       )
  		__A   : Tuple								= CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""       )
  
  		__A   : str								= {
  		    """unet""": unet,
  		    """controlnet""": controlnet,
  		    """scheduler""": scheduler,
  		    """vae""": vae,
  		    """text_encoder""": text_encoder,
  		    """tokenizer""": tokenizer,
  		    """safety_checker""": None,
  		    """feature_extractor""": None,
  		}
  		return components
  
  
  
  
  
  
  class     lowerCamelCase_			(  UpperCAmelCase_	,			UpperCAmelCase_	,			unittest.TestCase  ):
  	_lowercase		:      Dict    				=							StableDiffusionControlNetInpaintPipeline
  	_lowercase		:      Tuple    				=							TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
  	_lowercase		:      Dict    				=							TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
  
  
  
  
  	def 					lowerCAmelCase_					(				self	:    List[str]       ):
  		torch.manual_seed(0       )
  		__A   : Tuple								= 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(__A	:    Union[str, Any]       ):
  			if isinstance(__UpperCamelCase				,			torch.nn.Convad       ):
  				torch.nn.init.normal(m.weight       )
  				m.bias.data.fill_(1.0       )
  
  		__A   : Dict								= 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(__UpperCamelCase       )
  
  		torch.manual_seed(0       )
  		__A   : Union[str, 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(__UpperCamelCase       )
  
  		torch.manual_seed(0       )
  		__A   : Tuple								= DDIMScheduler(
  		    beta_start=0.0_0_0_8_5				,			beta_end=0.0_1_2				,			beta_schedule="""scaled_linear"""				,			clip_sample=__UpperCamelCase				,			set_alpha_to_one=__UpperCamelCase				,			)
  		torch.manual_seed(0       )
  		__A   : Optional[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       )
  		__A   : Dict								= CLIPTextConfig(
  		    bos_token_id=0				,			eos_token_id=2				,			hidden_size=32				,			intermediate_size=37				,			layer_norm_eps=1e-0_5				,			num_attention_heads=4				,			num_hidden_layers=5				,			pad_token_id=1				,			vocab_size=1000				,			)
  		__A   : Union[str, Any]								= CLIPTextModel(__UpperCamelCase       )
  		__A   : Dict								= CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""       )
  
  		__A   : Any								= MultiControlNetModel([controlneta, controlneta]       )
  
  		__A   : int								= {
  		    """unet""": unet,
  		    """controlnet""": controlnet,
  		    """scheduler""": scheduler,
  		    """vae""": vae,
  		    """text_encoder""": text_encoder,
  		    """tokenizer""": tokenizer,
  		    """safety_checker""": None,
  		    """feature_extractor""": None,
  		}
  		return components
  
  
  
  
  	def 					lowerCAmelCase_					(				self	:    Dict				,			__A	:    List[Any]				,			__A	:    Optional[Any]=0       ):
  		if str(__UpperCamelCase       ).startswith("""mps"""       ):
  			__A   : List[str]								= torch.manual_seed(__UpperCamelCase       )
  		else:
  			__A   : Dict								= torch.Generator(device=__UpperCamelCase       ).manual_seed(__UpperCamelCase       )
  
  		__A   : Optional[Any]								= 2
  
  		__A   : Optional[Any]								= [
  		    randn_tensor(
  		        (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)				,			generator=__UpperCamelCase				,			device=torch.device(__UpperCamelCase       )				,			),
  		    randn_tensor(
  		        (1, 3, 32 * controlnet_embedder_scale_factor, 32 * controlnet_embedder_scale_factor)				,			generator=__UpperCamelCase				,			device=torch.device(__UpperCamelCase       )				,			),
  		]
  		__A   : Union[str, Any]								= floats_tensor((1, 3, 32, 32)				,			rng=random.Random(__UpperCamelCase       )       ).to(__UpperCamelCase       )
  		__A   : List[str]								= init_image.cpu().permute(0				,			2				,			3				,			1       )[0]
  
  		__A   : Any								= Image.fromarray(np.uinta(__UpperCamelCase       )       ).convert("""RGB"""       ).resize((64, 64)       )
  		__A   : Dict								= Image.fromarray(np.uinta(init_image + 4       )       ).convert("""RGB"""       ).resize((64, 64)       )
  
  		__A   : int								= {
  		    """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 					lowerCAmelCase_					(				self	:    Dict       ):
  		__A   : Optional[Any]								= self.get_dummy_components()
  		__A   : str								= self.pipeline_class(**__UpperCamelCase       )
  		pipe.to(__UpperCamelCase       )
  
  		__A   : List[str]								= 1_0.0
  		__A   : List[Any]								= 4
  
  		__A   : str								= self.get_dummy_inputs(__UpperCamelCase       )
  		__A   : Tuple								= steps
  		__A   : Union[str, Any]								= scale
  		__A   : Any								= pipe(**__UpperCamelCase       )[0]
  
  		__A   : int								= self.get_dummy_inputs(__UpperCamelCase       )
  		__A   : List[str]								= steps
  		__A   : List[Any]								= scale
  		__A   : Optional[int]								= pipe(**__UpperCamelCase				,			control_guidance_start=0.1				,			control_guidance_end=0.2       )[0]
  
  		__A   : Optional[int]								= self.get_dummy_inputs(__UpperCamelCase       )
  		__A   : Union[str, Any]								= steps
  		__A   : int								= scale
  		__A   : int								= pipe(**__UpperCamelCase				,			control_guidance_start=[0.1, 0.3]				,			control_guidance_end=[0.2, 0.7]       )[0]
  
  		__A   : List[Any]								= self.get_dummy_inputs(__UpperCamelCase       )
  		__A   : List[Any]								= steps
  		__A   : List[Any]								= scale
  		__A   : Any								= pipe(**__UpperCamelCase				,			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 					lowerCAmelCase_					(				self	:    Union[str, Any]       ):
  		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 					lowerCAmelCase_					(				self	:    Dict       ):
  		self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=2e-3       )
  
  
  
  
  	def 					lowerCAmelCase_					(				self	:    Dict       ):
  		self._test_inference_batch_single_identical(expected_max_diff=2e-3       )
  
  
  
  
  	def 					lowerCAmelCase_					(				self	:    Dict       ):
  		__A   : Any								= self.get_dummy_components()
  		__A   : Optional[int]								= self.pipeline_class(**__UpperCamelCase       )
  		pipe.to(__UpperCamelCase       )
  		pipe.set_progress_bar_config(disable=__UpperCamelCase       )
  		with tempfile.TemporaryDirectory() as tmpdir:
  			try:
  				# save_pretrained is not implemented for Multi-ControlNet
  				pipe.save_pretrained(__UpperCamelCase       )
  			except NotImplementedError:
  				pass
  
  
  
  
  
  
  @slow
  @require_torch_gpu
  class     lowerCamelCase_			(  unittest.TestCase  ):
  
  
  
  
  	def 					lowerCAmelCase_					(				self	:    Optional[Any]       ):
  		super().tearDown()
  		gc.collect()
  		torch.cuda.empty_cache()
  
  
  
  
  	def 					lowerCAmelCase_					(				self	:    Union[str, Any]       ):
  		__A   : List[str]								= ControlNetModel.from_pretrained("""lllyasviel/sd-controlnet-canny"""       )
  
  		__A   : List[Any]								= StableDiffusionControlNetInpaintPipeline.from_pretrained(
  		    """runwayml/stable-diffusion-inpainting"""				,			safety_checker=__UpperCamelCase				,			controlnet=__UpperCamelCase       )
  		pipe.enable_model_cpu_offload()
  		pipe.set_progress_bar_config(disable=__UpperCamelCase       )
  
  		__A   : Dict								= torch.Generator(device="""cpu"""       ).manual_seed(0       )
  		__A   : Optional[Any]								= load_image(
  		    """https://huggingface.co/lllyasviel/sd-controlnet-canny/resolve/main/images/bird.png"""       ).resize((512, 512)       )
  
  		__A   : Any								= load_image(
  		    """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main"""
  		    """/stable_diffusion_inpaint/input_bench_mask.png"""       ).resize((512, 512)       )
  
  		__A   : Union[str, Any]								= """pitch black hole"""
  
  		__A   : Dict								= load_image(
  		    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd_controlnet/bird_canny.png"""       ).resize((512, 512)       )
  
  		__A   : Optional[Any]								= pipe(
  		    __UpperCamelCase				,			image=__UpperCamelCase				,			mask_image=__UpperCamelCase				,			control_image=__UpperCamelCase				,			generator=__UpperCamelCase				,			output_type="""np"""				,			num_inference_steps=3				,			)
  
  		__A   : str								= output.images[0]
  
  		assert image.shape == (512, 512, 3)
  
  		__A   : Optional[Any]								= 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 					lowerCAmelCase_					(				self	:    Dict       ):
  		__A   : Optional[Any]								= ControlNetModel.from_pretrained("""lllyasviel/control_v11p_sd15_inpaint"""       )
  
  		__A   : str								= StableDiffusionControlNetInpaintPipeline.from_pretrained(
  		    """runwayml/stable-diffusion-v1-5"""				,			safety_checker=__UpperCamelCase				,			controlnet=__UpperCamelCase       )
  		__A   : Optional[int]								= DDIMScheduler.from_config(pipe.scheduler.config       )
  		pipe.enable_model_cpu_offload()
  		pipe.set_progress_bar_config(disable=__UpperCamelCase       )
  
  		__A   : Tuple								= torch.Generator(device="""cpu"""       ).manual_seed(33       )
  
  		__A   : Any								= load_image(
  		    """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy.png"""       )
  		__A   : Optional[Any]								= init_image.resize((512, 512)       )
  
  		__A   : Any								= load_image(
  		    """https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/stable_diffusion_inpaint/boy_mask.png"""       )
  		__A   : Optional[Any]								= mask_image.resize((512, 512)       )
  
  		__A   : Optional[Any]								= """a handsome man with ray-ban sunglasses"""
  
  		def make_inpaint_condition(__A	:    Tuple				,			__A	:    Dict       ):
  			__A   : int								= np.array(image.convert("""RGB"""       )       ).astype(np.floataa       ) / 255.0
  			__A   : Union[str, Any]								= 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"
  			__A   : Optional[int]								= -1.0  # set as masked pixel
  			__A   : Dict								= np.expand_dims(__UpperCamelCase				,			0       ).transpose(0				,			3				,			1				,			2       )
  			__A   : str								= torch.from_numpy(__UpperCamelCase       )
  			return image
  
  		__A   : int								= make_inpaint_condition(__UpperCamelCase				,			__UpperCamelCase       )
  
  		__A   : Any								= pipe(
  		    __UpperCamelCase				,			image=__UpperCamelCase				,			mask_image=__UpperCamelCase				,			control_image=__UpperCamelCase				,			guidance_scale=9.0				,			eta=1.0				,			generator=__UpperCamelCase				,			num_inference_steps=20				,			output_type="""np"""				,			)
  		__A   : Union[str, Any]								= output.images[0]
  
  		assert image.shape == (512, 512, 3)
  
  		__A   : Any								= 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
  
  
  
  
  
  
style_context: 
  
  UpperCAmelCase_       :				str		   =      [
      [0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
      [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
      [0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
      [0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0],
      [0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0],
      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
      [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
      [0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0],
  ]
  def        __SCREAMING_SNAKE_CASE    (      a__						:      int ,a__						:      int ,a__						:      int ,a__						:      int					)				->							bool:
  	return 0 <= row < rows and 0 <= col < cols
  def        __SCREAMING_SNAKE_CASE    (      a__						:      int ,a__						:      int ,a__						:      set ,a__						:      list[list[int]]					)				->							int:
  	__A   : Union[str, Any]								= len(a__					)
  	__A   : Any								= len(mat[0]					)
  	if is_safe(a__ ,a__ ,a__ ,a__					) and (row, col) not in seen and mat[row][col] == 1:
  		seen.add((row, col)					)
  		return (
  		    1
  		    + depth_first_search(row + 1 ,a__ ,a__ ,a__					)
  		    + depth_first_search(row - 1 ,a__ ,a__ ,a__					)
  		    + depth_first_search(a__ ,col + 1 ,a__ ,a__					)
  		    + depth_first_search(a__ ,col - 1 ,a__ ,a__					)
  		)
  	else:
  		return 0
  def        __SCREAMING_SNAKE_CASE    (      a__						:      list[list[int]]					)				->							int:
  	__A   : set								= set()
  
  	__A   : Union[str, Any]								= 0
  	for row, line in enumerate(a__					):
  		for col, item in enumerate(a__					):
  			if item == 1 and (row, col) not in seen:
  				# Maximizing the area
  				__A   : Optional[Any]								= max(a__ ,depth_first_search(a__ ,a__ ,a__ ,a__					)					)
  	return max_area
  
  
  if __name__ == "__main__":
  			import doctest
  
  			print(find_max_area(matrix))  # Output -> 6
  			doctest.testmod()
  
  
  
  
  
  