






import gc
import random
import tempfile
import unittest

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

from diffusers import AutoencoderKL, DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler, UNetaDConditionModel
from diffusers.pipelines.semantic_stable_diffusion import SemanticStableDiffusionPipeline as StableDiffusionPipeline
from diffusers.utils import floats_tensor, nightly, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()







class       UpperCAmelCase_						( unittest.TestCase			):



      """simple docstring"""
      def    UpperCAmelCase						(    self			)    ->				Any:
          # clean up the VRAM after each test
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()
      @property
      def    UpperCAmelCase						(    self			)    ->				int:
          UpperCamelCase	:Union[str, Any]     							=       1
          UpperCamelCase	:Union[str, Any]     							=       3
          UpperCamelCase	:Dict     							=       (32, 32)

          UpperCamelCase	:Optional[int]     							=       floats_tensor((batch_size, num_channels) + sizes   ,    rng=random.Random(0			)			).to(SCREAMING_SNAKE_CASE_			)
          return image
      @property
      def    UpperCAmelCase						(    self			)    ->				Optional[int]:
          torch.manual_seed(0			)
          UpperCamelCase	: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   ,    )
          return model
      @property
      def    UpperCAmelCase						(    self			)    ->				Optional[Any]:
          torch.manual_seed(0			)
          UpperCamelCase	:Optional[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   ,    )
          return model
      @property
      def    UpperCAmelCase						(    self			)    ->				Union[str, Any]:
          torch.manual_seed(0			)
          UpperCamelCase	: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   ,    )
          return CLIPTextModel(SCREAMING_SNAKE_CASE_			)
      @property
      def    UpperCAmelCase						(    self			)    ->				List[str]:
          def extract(*SCREAMING_SNAKE_CASE_   ,    **SCREAMING_SNAKE_CASE_			):







              class       UpperCAmelCase_						:



                    """simple docstring"""
                    def __init__(    self			)    ->				Dict:
                        UpperCamelCase	:Tuple     							=       torch.ones([0]			)




                    def    UpperCAmelCase						(    self   ,    SCREAMING_SNAKE_CASE_			)    ->				Dict:
                        self.pixel_values.to(SCREAMING_SNAKE_CASE_			)
                        return self







              return Out()

          return extract
      def    UpperCAmelCase						(    self			)    ->				List[str]:
          UpperCamelCase	:List[Any]     							=       '''cpu'''  # ensure determinism for the device-dependent torch.Generator
          UpperCamelCase	:Any     							=       self.dummy_cond_unet
          UpperCamelCase	:List[Any]     							=       DDIMScheduler(
              beta_start=0.0_0085   ,    beta_end=0.012   ,    beta_schedule='''scaled_linear'''   ,    clip_sample=SCREAMING_SNAKE_CASE_   ,    set_alpha_to_one=SCREAMING_SNAKE_CASE_   ,    )

          UpperCamelCase	:Optional[int]     							=       self.dummy_vae
          UpperCamelCase	:Union[str, Any]     							=       self.dummy_text_encoder
          UpperCamelCase	:int     							=       CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''			)

          # make sure here that pndm scheduler skips prk
          UpperCamelCase	:List[str]     							=       StableDiffusionPipeline(
              unet=SCREAMING_SNAKE_CASE_   ,    scheduler=SCREAMING_SNAKE_CASE_   ,    vae=SCREAMING_SNAKE_CASE_   ,    text_encoder=SCREAMING_SNAKE_CASE_   ,    tokenizer=SCREAMING_SNAKE_CASE_   ,    safety_checker=SCREAMING_SNAKE_CASE_   ,    feature_extractor=self.dummy_extractor   ,    )
          UpperCamelCase	:int     							=       sd_pipe.to(SCREAMING_SNAKE_CASE_			)
          sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_			)

          UpperCamelCase	:Union[str, Any]     							=       '''A painting of a squirrel eating a burger'''

          UpperCamelCase	:str     							=       torch.Generator(device=SCREAMING_SNAKE_CASE_			).manual_seed(0			)
          UpperCamelCase	:str     							=       sd_pipe([prompt]   ,    generator=SCREAMING_SNAKE_CASE_   ,    guidance_scale=6.0   ,    num_inference_steps=2   ,    output_type='''np'''			)
          UpperCamelCase	:Optional[int]     							=       output.images

          UpperCamelCase	:str     							=       torch.Generator(device=SCREAMING_SNAKE_CASE_			).manual_seed(0			)
          UpperCamelCase	:Dict     							=       sd_pipe(
              [prompt]   ,    generator=SCREAMING_SNAKE_CASE_   ,    guidance_scale=6.0   ,    num_inference_steps=2   ,    output_type='''np'''   ,    return_dict=SCREAMING_SNAKE_CASE_   ,    )[0]

          UpperCamelCase	:Optional[int]     							=       image[0, -3:, -3:, -1]
          UpperCamelCase	:str     							=       image_from_tuple[0, -3:, -3:, -1]

          assert image.shape == (1, 64, 64, 3)
          UpperCamelCase	:Optional[int]     							=       np.array([0.5753, 0.6114, 0.5001, 0.5034, 0.5470, 0.4729, 0.4971, 0.4867, 0.4867]			)

          assert np.abs(image_slice.flatten() - expected_slice			).max() < 1e-2
          assert np.abs(image_from_tuple_slice.flatten() - expected_slice			).max() < 1e-2
      def    UpperCAmelCase						(    self			)    ->				Tuple:
          UpperCamelCase	:Union[str, Any]     							=       '''cpu'''  # ensure determinism for the device-dependent torch.Generator
          UpperCamelCase	:List[Any]     							=       self.dummy_cond_unet
          UpperCamelCase	:Optional[int]     							=       PNDMScheduler(skip_prk_steps=SCREAMING_SNAKE_CASE_			)
          UpperCamelCase	:Optional[int]     							=       self.dummy_vae
          UpperCamelCase	:List[Any]     							=       self.dummy_text_encoder
          UpperCamelCase	:Tuple     							=       CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''			)

          # make sure here that pndm scheduler skips prk
          UpperCamelCase	:Tuple     							=       StableDiffusionPipeline(
              unet=SCREAMING_SNAKE_CASE_   ,    scheduler=SCREAMING_SNAKE_CASE_   ,    vae=SCREAMING_SNAKE_CASE_   ,    text_encoder=SCREAMING_SNAKE_CASE_   ,    tokenizer=SCREAMING_SNAKE_CASE_   ,    safety_checker=SCREAMING_SNAKE_CASE_   ,    feature_extractor=self.dummy_extractor   ,    )
          UpperCamelCase	:int     							=       sd_pipe.to(SCREAMING_SNAKE_CASE_			)
          sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_			)

          UpperCamelCase	:Tuple     							=       '''A painting of a squirrel eating a burger'''
          UpperCamelCase	:Tuple     							=       torch.Generator(device=SCREAMING_SNAKE_CASE_			).manual_seed(0			)
          UpperCamelCase	:Optional[Any]     							=       sd_pipe([prompt]   ,    generator=SCREAMING_SNAKE_CASE_   ,    guidance_scale=6.0   ,    num_inference_steps=2   ,    output_type='''np'''			)

          UpperCamelCase	:Tuple     							=       output.images

          UpperCamelCase	:Union[str, Any]     							=       torch.Generator(device=SCREAMING_SNAKE_CASE_			).manual_seed(0			)
          UpperCamelCase	:str     							=       sd_pipe(
              [prompt]   ,    generator=SCREAMING_SNAKE_CASE_   ,    guidance_scale=6.0   ,    num_inference_steps=2   ,    output_type='''np'''   ,    return_dict=SCREAMING_SNAKE_CASE_   ,    )[0]

          UpperCamelCase	:Optional[int]     							=       image[0, -3:, -3:, -1]
          UpperCamelCase	:Tuple     							=       image_from_tuple[0, -3:, -3:, -1]

          assert image.shape == (1, 64, 64, 3)
          UpperCamelCase	:Any     							=       np.array([0.5122, 0.5712, 0.4825, 0.5053, 0.5646, 0.4769, 0.5179, 0.4894, 0.4994]			)

          assert np.abs(image_slice.flatten() - expected_slice			).max() < 1e-2
          assert np.abs(image_from_tuple_slice.flatten() - expected_slice			).max() < 1e-2
      def    UpperCAmelCase						(    self			)    ->				Optional[Any]:
          UpperCamelCase	:Tuple     							=       StableDiffusionPipeline.from_pretrained(
              '''hf-internal-testing/tiny-stable-diffusion-lms-pipe'''   ,    safety_checker=SCREAMING_SNAKE_CASE_			)
          assert isinstance(SCREAMING_SNAKE_CASE_   ,    SCREAMING_SNAKE_CASE_			)
          assert isinstance(pipe.scheduler   ,    SCREAMING_SNAKE_CASE_			)
          assert pipe.safety_checker is None

          UpperCamelCase	:Tuple     							=       pipe('''example prompt'''   ,    num_inference_steps=2			).images[0]
          assert image is not None

          # check that there's no error when saving a pipeline with one of the models being None
          with tempfile.TemporaryDirectory() as tmpdirname:
              pipe.save_pretrained(SCREAMING_SNAKE_CASE_			)
              UpperCamelCase	:Tuple     							=       StableDiffusionPipeline.from_pretrained(SCREAMING_SNAKE_CASE_			)

          # sanity check that the pipeline still works
          assert pipe.safety_checker is None
          UpperCamelCase	:List[Any]     							=       pipe('''example prompt'''   ,    num_inference_steps=2			).images[0]
          assert image is not None




      @unittest.skipIf(torch_device != '''cuda'''   ,    '''This test requires a GPU'''			)
      def    UpperCAmelCase						(    self			)    ->				Optional[int]:
          UpperCamelCase	:Optional[int]     							=       self.dummy_cond_unet
          UpperCamelCase	:List[Any]     							=       PNDMScheduler(skip_prk_steps=SCREAMING_SNAKE_CASE_			)
          UpperCamelCase	:Any     							=       self.dummy_vae
          UpperCamelCase	:Tuple     							=       self.dummy_text_encoder
          UpperCamelCase	:str     							=       CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''			)

          # put models in fp16
          UpperCamelCase	:Optional[int]     							=       unet.half()
          UpperCamelCase	:Tuple     							=       vae.half()
          UpperCamelCase	:Optional[Any]     							=       bert.half()

          # make sure here that pndm scheduler skips prk
          UpperCamelCase	:Union[str, Any]     							=       StableDiffusionPipeline(
              unet=SCREAMING_SNAKE_CASE_   ,    scheduler=SCREAMING_SNAKE_CASE_   ,    vae=SCREAMING_SNAKE_CASE_   ,    text_encoder=SCREAMING_SNAKE_CASE_   ,    tokenizer=SCREAMING_SNAKE_CASE_   ,    safety_checker=SCREAMING_SNAKE_CASE_   ,    feature_extractor=self.dummy_extractor   ,    )
          UpperCamelCase	:Tuple     							=       sd_pipe.to(SCREAMING_SNAKE_CASE_			)
          sd_pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_			)

          UpperCamelCase	:Any     							=       '''A painting of a squirrel eating a burger'''
          UpperCamelCase	:Tuple     							=       sd_pipe([prompt]   ,    num_inference_steps=2   ,    output_type='''np'''			).images

          assert image.shape == (1, 64, 64, 3)







@nightly
@require_torch_gpu
class       UpperCAmelCase_						( unittest.TestCase			):



      """simple docstring"""
      def    UpperCAmelCase						(    self			)    ->				Optional[Any]:
          # clean up the VRAM after each test
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()
      def    UpperCAmelCase						(    self			)    ->				Optional[Any]:
          UpperCamelCase	:str     							=       '''cuda'''
          UpperCamelCase	:Optional[Any]     							=       StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''			)
          UpperCamelCase	:Optional[int]     							=       pipe.to(SCREAMING_SNAKE_CASE_			)
          pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_			)

          UpperCamelCase	:Dict     							=       '''a photo of a cat'''
          UpperCamelCase	:int     							=       {
              '''editing_prompt''': ['''sunglasses'''],
              '''reverse_editing_direction''': [False],
              '''edit_warmup_steps''': 10,
              '''edit_guidance_scale''': 6,
              '''edit_threshold''': 0.95,
              '''edit_momentum_scale''': 0.5,
              '''edit_mom_beta''': 0.6,
          }

          UpperCamelCase	:Any     							=       3
          UpperCamelCase	:List[Any]     							=       7

          # no sega enabled
          UpperCamelCase	:Optional[int]     							=       torch.Generator(SCREAMING_SNAKE_CASE_			)
          generator.manual_seed(SCREAMING_SNAKE_CASE_			)
          UpperCamelCase	:str     							=       pipe(
              [prompt]   ,    generator=SCREAMING_SNAKE_CASE_   ,    guidance_scale=SCREAMING_SNAKE_CASE_   ,    num_inference_steps=50   ,    output_type='''np'''   ,    width=512   ,    height=512   ,    )

          UpperCamelCase	:Union[str, Any]     							=       output.images
          UpperCamelCase	:str     							=       image[0, -3:, -3:, -1]
          UpperCamelCase	:List[Any]     							=       [
              0.3467_3113,
              0.3849_2733,
              0.3759_7352,
              0.3408_6335,
              0.3565_0748,
              0.3557_9205,
              0.338_4763,
              0.3434_0236,
              0.357_3271,
          ]

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

          assert np.abs(image_slice.flatten() - expected_slice			).max() < 1e-2

          # with sega enabled
          # generator = torch.manual_seed(seed)
          generator.manual_seed(SCREAMING_SNAKE_CASE_			)
          UpperCamelCase	:List[Any]     							=       pipe(
              [prompt]   ,    generator=SCREAMING_SNAKE_CASE_   ,    guidance_scale=SCREAMING_SNAKE_CASE_   ,    num_inference_steps=50   ,    output_type='''np'''   ,    width=512   ,    height=512   ,    **SCREAMING_SNAKE_CASE_   ,    )

          UpperCamelCase	:List[str]     							=       output.images
          UpperCamelCase	:Dict     							=       image[0, -3:, -3:, -1]
          UpperCamelCase	:Optional[int]     							=       [
              0.4188_7826,
              0.3772_8766,
              0.3013_8272,
              0.4141_6335,
              0.4166_4985,
              0.3628_3392,
              0.3619_1246,
              0.4336_4465,
              0.4300_1732,
          ]

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

          assert np.abs(image_slice.flatten() - expected_slice			).max() < 1e-2
      def    UpperCAmelCase						(    self			)    ->				str:
          UpperCamelCase	:int     							=       '''cuda'''
          UpperCamelCase	:Optional[Any]     							=       StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''			)
          UpperCamelCase	:List[str]     							=       pipe.to(SCREAMING_SNAKE_CASE_			)
          pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_			)

          UpperCamelCase	:List[str]     							=       '''an image of a crowded boulevard, realistic, 4k'''
          UpperCamelCase	:Optional[Any]     							=       {
              '''editing_prompt''': '''crowd, crowded, people''',
              '''reverse_editing_direction''': True,
              '''edit_warmup_steps''': 10,
              '''edit_guidance_scale''': 8.3,
              '''edit_threshold''': 0.9,
              '''edit_momentum_scale''': 0.5,
              '''edit_mom_beta''': 0.6,
          }

          UpperCamelCase	:Dict     							=       9
          UpperCamelCase	:List[str]     							=       7

          # no sega enabled
          UpperCamelCase	:Optional[Any]     							=       torch.Generator(SCREAMING_SNAKE_CASE_			)
          generator.manual_seed(SCREAMING_SNAKE_CASE_			)
          UpperCamelCase	:List[Any]     							=       pipe(
              [prompt]   ,    generator=SCREAMING_SNAKE_CASE_   ,    guidance_scale=SCREAMING_SNAKE_CASE_   ,    num_inference_steps=50   ,    output_type='''np'''   ,    width=512   ,    height=512   ,    )

          UpperCamelCase	:List[str]     							=       output.images
          UpperCamelCase	:int     							=       image[0, -3:, -3:, -1]
          UpperCamelCase	:int     							=       [
              0.4349_7998,
              0.9181_4065,
              0.754_0739,
              0.5558_0205,
              0.846_7265,
              0.538_9691,
              0.6257_4506,
              0.5889_7763,
              0.5092_6757,
          ]

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

          assert np.abs(image_slice.flatten() - expected_slice			).max() < 1e-2

          # with sega enabled
          # generator = torch.manual_seed(seed)
          generator.manual_seed(SCREAMING_SNAKE_CASE_			)
          UpperCamelCase	:int     							=       pipe(
              [prompt]   ,    generator=SCREAMING_SNAKE_CASE_   ,    guidance_scale=SCREAMING_SNAKE_CASE_   ,    num_inference_steps=50   ,    output_type='''np'''   ,    width=512   ,    height=512   ,    **SCREAMING_SNAKE_CASE_   ,    )

          UpperCamelCase	:Dict     							=       output.images
          UpperCamelCase	:List[str]     							=       image[0, -3:, -3:, -1]
          UpperCamelCase	:Union[str, Any]     							=       [
              0.308_9719,
              0.3050_0144,
              0.2901_6042,
              0.3063_0964,
              0.32_5687,
              0.2941_9225,
              0.290_8091,
              0.2872_3598,
              0.2769_6294,
          ]

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

          assert np.abs(image_slice.flatten() - expected_slice			).max() < 1e-2
      def    UpperCAmelCase						(    self			)    ->				Any:
          UpperCamelCase	:int     							=       '''cuda'''
          UpperCamelCase	:Optional[Any]     							=       StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''			)
          UpperCamelCase	:List[str]     							=       pipe.to(SCREAMING_SNAKE_CASE_			)
          pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_			)

          UpperCamelCase	:Tuple     							=       '''a castle next to a river'''
          UpperCamelCase	:Any     							=       {
              '''editing_prompt''': ['''boat on a river, boat''', '''monet, impression, sunrise'''],
              '''reverse_editing_direction''': False,
              '''edit_warmup_steps''': [15, 18],
              '''edit_guidance_scale''': 6,
              '''edit_threshold''': [0.9, 0.8],
              '''edit_momentum_scale''': 0.5,
              '''edit_mom_beta''': 0.6,
          }

          UpperCamelCase	:int     							=       48
          UpperCamelCase	:Any     							=       7

          # no sega enabled
          UpperCamelCase	:Dict     							=       torch.Generator(SCREAMING_SNAKE_CASE_			)
          generator.manual_seed(SCREAMING_SNAKE_CASE_			)
          UpperCamelCase	:int     							=       pipe(
              [prompt]   ,    generator=SCREAMING_SNAKE_CASE_   ,    guidance_scale=SCREAMING_SNAKE_CASE_   ,    num_inference_steps=50   ,    output_type='''np'''   ,    width=512   ,    height=512   ,    )

          UpperCamelCase	:Dict     							=       output.images
          UpperCamelCase	:int     							=       image[0, -3:, -3:, -1]
          UpperCamelCase	:Tuple     							=       [
              0.7516_3555,
              0.7603_7145,
              0.6_1785,
              0.918_9673,
              0.862_7701,
              0.8518_9694,
              0.851_2813,
              0.8701_2076,
              0.831_2857,
          ]

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

          assert np.abs(image_slice.flatten() - expected_slice			).max() < 1e-2

          # with sega enabled
          # generator = torch.manual_seed(seed)
          generator.manual_seed(SCREAMING_SNAKE_CASE_			)
          UpperCamelCase	:List[str]     							=       pipe(
              [prompt]   ,    generator=SCREAMING_SNAKE_CASE_   ,    guidance_scale=SCREAMING_SNAKE_CASE_   ,    num_inference_steps=50   ,    output_type='''np'''   ,    width=512   ,    height=512   ,    **SCREAMING_SNAKE_CASE_   ,    )

          UpperCamelCase	:List[Any]     							=       output.images
          UpperCamelCase	:Tuple     							=       image[0, -3:, -3:, -1]
          UpperCamelCase	:List[Any]     							=       [
              0.7355_3365,
              0.753_7271,
              0.7434_1905,
              0.6648_0356,
              0.647_2925,
              0.6303_9416,
              0.6481_2905,
              0.674_9717,
              0.651_7102,
          ]

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

          assert np.abs(image_slice.flatten() - expected_slice			).max() < 1e-2




      def    UpperCAmelCase						(    self			)    ->				List[str]:
          UpperCamelCase	:Union[str, Any]     							=       '''cuda'''
          UpperCamelCase	:Union[str, Any]     							=       StableDiffusionPipeline.from_pretrained('''runwayml/stable-diffusion-v1-5'''   ,    torch_dtype=torch.floataa			)
          UpperCamelCase	:int     							=       pipe.to(SCREAMING_SNAKE_CASE_			)
          pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE_			)

          UpperCamelCase	:Union[str, Any]     							=       '''a photo of a cat'''
          UpperCamelCase	:int     							=       {
              '''editing_prompt''': ['''sunglasses'''],
              '''reverse_editing_direction''': [False],
              '''edit_warmup_steps''': 10,
              '''edit_guidance_scale''': 6,
              '''edit_threshold''': 0.95,
              '''edit_momentum_scale''': 0.5,
              '''edit_mom_beta''': 0.6,
          }

          UpperCamelCase	:str     							=       3
          UpperCamelCase	:Optional[Any]     							=       7

          # no sega enabled
          UpperCamelCase	:Optional[int]     							=       torch.Generator(SCREAMING_SNAKE_CASE_			)
          generator.manual_seed(SCREAMING_SNAKE_CASE_			)
          UpperCamelCase	:Any     							=       pipe(
              [prompt]   ,    generator=SCREAMING_SNAKE_CASE_   ,    guidance_scale=SCREAMING_SNAKE_CASE_   ,    num_inference_steps=50   ,    output_type='''np'''   ,    width=512   ,    height=512   ,    )

          UpperCamelCase	:Dict     							=       output.images
          UpperCamelCase	:int     							=       image[0, -3:, -3:, -1]
          UpperCamelCase	:Optional[Any]     							=       [
              0.3488_7695,
              0.387_6953,
              0.375,
              0.3442_3828,
              0.358_1543,
              0.3571_7773,
              0.338_3789,
              0.3457_0312,
              0.35_9375,
          ]

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

          assert np.abs(image_slice.flatten() - expected_slice			).max() < 1e-2

          # with sega enabled
          # generator = torch.manual_seed(seed)
          generator.manual_seed(SCREAMING_SNAKE_CASE_			)
          UpperCamelCase	:Dict     							=       pipe(
              [prompt]   ,    generator=SCREAMING_SNAKE_CASE_   ,    guidance_scale=SCREAMING_SNAKE_CASE_   ,    num_inference_steps=50   ,    output_type='''np'''   ,    width=512   ,    height=512   ,    **SCREAMING_SNAKE_CASE_   ,    )

          UpperCamelCase	:Dict     							=       output.images
          UpperCamelCase	:Tuple     							=       image[0, -3:, -3:, -1]
          UpperCamelCase	:Dict     							=       [
              0.4228_5156,
              0.3691_4062,
              0.2907_7148,
              0.4204_1016,
              0.4191_8945,
              0.3549_8047,
              0.361_8164,
              0.442_3828,
              0.4311_5234,
          ]

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

          assert np.abs(image_slice.flatten() - expected_slice			).max() < 1e-2













def   _A       (    SCREAMING_SNAKE_CASE__  :     int	):
    UpperCamelCase	:Optional[Any]     							=       9

    while num > 0:
        if num % 10 != digit:
            return False
        num //= 100
        digit -= 1

    return True


def   _A       (    ):
    UpperCamelCase	:List[str]     							=       138902663

    while not is_square_form(num * num	):
        if num % 10 == 3:
            num -= 6  # (3 - 6) % 10 = 7
        else:
            num -= 4  # (7 - 4) % 10 = 3

    return num * 10


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





