






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.stable_diffusion_safe import StableDiffusionPipelineSafe as StableDiffusionPipeline
from diffusers.utils import floats_tensor, nightly, torch_device
from diffusers.utils.testing_utils import require_torch_gpu


class      lowercase__     (			unittest.TestCase	):

	def 		UpperCAmelCase  (							self       )->					Dict:







							'''simple docstring'''





							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()

	@property
	def 		UpperCAmelCase  (							self       )->					int:







							'''simple docstring'''





							lowerCAmelCase__       =						1
							lowerCAmelCase__       =						3
							lowerCAmelCase__       =						(32, 32)

							lowerCAmelCase__       =						floats_tensor((batch_size, num_channels) + sizes		,    rng=random.Random(0       )       ).to(__UpperCAmelCase       )
							return image

	@property
	def 		UpperCAmelCase  (							self       )->					List[str]:







							'''simple docstring'''





							torch.manual_seed(0       )
							lowerCAmelCase__       =						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]:







							'''simple docstring'''





							torch.manual_seed(0       )
							lowerCAmelCase__       =						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       )->					Dict:







							'''simple docstring'''





							torch.manual_seed(0       )
							lowerCAmelCase__       =						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		,    )
							return CLIPTextModel(__UpperCAmelCase       )

	@property
	def 		UpperCAmelCase  (							self       )->					Any:







							'''simple docstring'''





							def extract(*__UpperCAmelCase		,    **__UpperCAmelCase       ):


													class      lowercase__     :

														def __init__(							self       )->					Tuple:







																				'''simple docstring'''





																				lowerCAmelCase__       =						torch.ones([0]       )


														def 		UpperCAmelCase  (							self		,    __UpperCAmelCase       )->					List[Any]:







																				'''simple docstring'''





																				self.pixel_values.to(__UpperCAmelCase       )
																				return self





													return Out()

							return extract

	def 		UpperCAmelCase  (							self       )->					Dict:







							'''simple docstring'''





							lowerCAmelCase__       =						"cpu"  # ensure determinism for the device-dependent torch.Generator
							lowerCAmelCase__       =						self.dummy_cond_unet
							lowerCAmelCase__       =						DDIMScheduler(
							    beta_start=0.00_085		,    beta_end=0.012		,    beta_schedule="scaled_linear"		,    clip_sample=__UpperCAmelCase		,    set_alpha_to_one=__UpperCAmelCase		,    )

							lowerCAmelCase__       =						self.dummy_vae
							lowerCAmelCase__       =						self.dummy_text_encoder
							lowerCAmelCase__       =						CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"       )

							# make sure here that pndm scheduler skips prk
							lowerCAmelCase__       =						StableDiffusionPipeline(
							    unet=__UpperCAmelCase		,    scheduler=__UpperCAmelCase		,    vae=__UpperCAmelCase		,    text_encoder=__UpperCAmelCase		,    tokenizer=__UpperCAmelCase		,    safety_checker=__UpperCAmelCase		,    feature_extractor=self.dummy_extractor		,    )
							lowerCAmelCase__       =						sd_pipe.to(__UpperCAmelCase       )
							sd_pipe.set_progress_bar_config(disable=__UpperCAmelCase       )

							lowerCAmelCase__       =						"A painting of a squirrel eating a burger"

							lowerCAmelCase__       =						torch.Generator(device=__UpperCAmelCase       ).manual_seed(0       )
							lowerCAmelCase__       =						sd_pipe([prompt]		,    generator=__UpperCAmelCase		,    guidance_scale=6.0		,    num_inference_steps=2		,    output_type="np"       )
							lowerCAmelCase__       =						output.images

							lowerCAmelCase__       =						torch.Generator(device=__UpperCAmelCase       ).manual_seed(0       )
							lowerCAmelCase__       =						sd_pipe(
							    [prompt]		,    generator=__UpperCAmelCase		,    guidance_scale=6.0		,    num_inference_steps=2		,    output_type="np"		,    return_dict=__UpperCAmelCase		,    )[0]

							lowerCAmelCase__       =						image[0, -3:, -3:, -1]
							lowerCAmelCase__       =						image_from_tuple[0, -3:, -3:, -1]

							assert image.shape == (1, 64, 64, 3)
							lowerCAmelCase__       =						np.array([0.5_756, 0.6_118, 0.5_005, 0.5_041, 0.5_471, 0.4_726, 0.4_976, 0.4_865, 0.4_864]       )

							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:







							'''simple docstring'''





							lowerCAmelCase__       =						"cpu"  # ensure determinism for the device-dependent torch.Generator
							lowerCAmelCase__       =						self.dummy_cond_unet
							lowerCAmelCase__       =						PNDMScheduler(skip_prk_steps=__UpperCAmelCase       )
							lowerCAmelCase__       =						self.dummy_vae
							lowerCAmelCase__       =						self.dummy_text_encoder
							lowerCAmelCase__       =						CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"       )

							# make sure here that pndm scheduler skips prk
							lowerCAmelCase__       =						StableDiffusionPipeline(
							    unet=__UpperCAmelCase		,    scheduler=__UpperCAmelCase		,    vae=__UpperCAmelCase		,    text_encoder=__UpperCAmelCase		,    tokenizer=__UpperCAmelCase		,    safety_checker=__UpperCAmelCase		,    feature_extractor=self.dummy_extractor		,    )
							lowerCAmelCase__       =						sd_pipe.to(__UpperCAmelCase       )
							sd_pipe.set_progress_bar_config(disable=__UpperCAmelCase       )

							lowerCAmelCase__       =						"A painting of a squirrel eating a burger"
							lowerCAmelCase__       =						torch.Generator(device=__UpperCAmelCase       ).manual_seed(0       )
							lowerCAmelCase__       =						sd_pipe([prompt]		,    generator=__UpperCAmelCase		,    guidance_scale=6.0		,    num_inference_steps=2		,    output_type="np"       )

							lowerCAmelCase__       =						output.images

							lowerCAmelCase__       =						torch.Generator(device=__UpperCAmelCase       ).manual_seed(0       )
							lowerCAmelCase__       =						sd_pipe(
							    [prompt]		,    generator=__UpperCAmelCase		,    guidance_scale=6.0		,    num_inference_steps=2		,    output_type="np"		,    return_dict=__UpperCAmelCase		,    )[0]

							lowerCAmelCase__       =						image[0, -3:, -3:, -1]
							lowerCAmelCase__       =						image_from_tuple[0, -3:, -3:, -1]

							assert image.shape == (1, 64, 64, 3)
							lowerCAmelCase__       =						np.array([0.5_125, 0.5_716, 0.4_828, 0.5_060, 0.5_650, 0.4_768, 0.5_185, 0.4_895, 0.4_993]       )

							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:







							'''simple docstring'''





							lowerCAmelCase__       =						StableDiffusionPipeline.from_pretrained(
							    "hf-internal-testing/tiny-stable-diffusion-lms-pipe"		,    safety_checker=__UpperCAmelCase       )
							assert isinstance(__UpperCAmelCase		,    __UpperCAmelCase       )
							assert isinstance(pipe.scheduler		,    __UpperCAmelCase       )
							assert pipe.safety_checker is None

							lowerCAmelCase__       =						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(__UpperCAmelCase       )
													lowerCAmelCase__       =						StableDiffusionPipeline.from_pretrained(__UpperCAmelCase       )

							# sanity check that the pipeline still works
							assert pipe.safety_checker is None
							lowerCAmelCase__       =						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[Any]:







							'''simple docstring'''





							lowerCAmelCase__       =						self.dummy_cond_unet
							lowerCAmelCase__       =						PNDMScheduler(skip_prk_steps=__UpperCAmelCase       )
							lowerCAmelCase__       =						self.dummy_vae
							lowerCAmelCase__       =						self.dummy_text_encoder
							lowerCAmelCase__       =						CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"       )

							# put models in fp16
							lowerCAmelCase__       =						unet.half()
							lowerCAmelCase__       =						vae.half()
							lowerCAmelCase__       =						bert.half()

							# make sure here that pndm scheduler skips prk
							lowerCAmelCase__       =						StableDiffusionPipeline(
							    unet=__UpperCAmelCase		,    scheduler=__UpperCAmelCase		,    vae=__UpperCAmelCase		,    text_encoder=__UpperCAmelCase		,    tokenizer=__UpperCAmelCase		,    safety_checker=__UpperCAmelCase		,    feature_extractor=self.dummy_extractor		,    )
							lowerCAmelCase__       =						sd_pipe.to(__UpperCAmelCase       )
							sd_pipe.set_progress_bar_config(disable=__UpperCAmelCase       )

							lowerCAmelCase__       =						"A painting of a squirrel eating a burger"
							lowerCAmelCase__       =						sd_pipe([prompt]		,    num_inference_steps=2		,    output_type="np"       ).images

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





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

	def 		UpperCAmelCase  (							self       )->					Tuple:







							'''simple docstring'''





							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()

	def 		UpperCAmelCase  (							self       )->					Optional[int]:







							'''simple docstring'''





							lowerCAmelCase__       =						StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"		,    safety_checker=__UpperCAmelCase       )
							lowerCAmelCase__       =						LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config       )
							lowerCAmelCase__       =						sd_pipe.to(__UpperCAmelCase       )
							sd_pipe.set_progress_bar_config(disable=__UpperCAmelCase       )

							lowerCAmelCase__       =						(
							    "portrait of girl with smokey eyes makeup in abandoned hotel, grange clothes, redshift, wide high angle"
							    " coloured polaroid photograph with flash, kodak film, hyper real, stunning moody cinematography, with"
							    " anamorphic lenses, by maripol, fallen angels by wong kar - wai, style of suspiria and neon demon and"
							    " children from bahnhof zoo, detailed "
							)
							lowerCAmelCase__       =						4003660346
							lowerCAmelCase__       =						7

							# without safety guidance (sld_guidance_scale = 0)
							lowerCAmelCase__       =						torch.manual_seed(__UpperCAmelCase       )
							lowerCAmelCase__       =						sd_pipe(
							    [prompt]		,    generator=__UpperCAmelCase		,    guidance_scale=__UpperCAmelCase		,    num_inference_steps=50		,    output_type="np"		,    width=512		,    height=512		,    sld_guidance_scale=0		,    )

							lowerCAmelCase__       =						output.images
							lowerCAmelCase__       =						image[0, -3:, -3:, -1]
							lowerCAmelCase__       =						[0.2_278, 0.2_231, 0.2_249, 0.2_333, 0.2_303, 0.1_885, 0.2_273, 0.2_144, 0.2_176]

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

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

							# without safety guidance (strong configuration)
							lowerCAmelCase__       =						torch.manual_seed(__UpperCAmelCase       )
							lowerCAmelCase__       =						sd_pipe(
							    [prompt]		,    generator=__UpperCAmelCase		,    guidance_scale=__UpperCAmelCase		,    num_inference_steps=50		,    output_type="np"		,    width=512		,    height=512		,    sld_guidance_scale=2000		,    sld_warmup_steps=7		,    sld_threshold=0.025		,    sld_momentum_scale=0.5		,    sld_mom_beta=0.7		,    )

							lowerCAmelCase__       =						output.images
							lowerCAmelCase__       =						image[0, -3:, -3:, -1]
							lowerCAmelCase__       =						[0.2_383, 0.2_276, 0.236, 0.2_192, 0.2_186, 0.2_053, 0.1_971, 0.1_901, 0.1_719]

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

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

	def 		UpperCAmelCase  (							self       )->					Tuple:







							'''simple docstring'''





							lowerCAmelCase__       =						StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"		,    safety_checker=__UpperCAmelCase       )
							lowerCAmelCase__       =						LMSDiscreteScheduler.from_config(sd_pipe.scheduler.config       )
							lowerCAmelCase__       =						sd_pipe.to(__UpperCAmelCase       )
							sd_pipe.set_progress_bar_config(disable=__UpperCAmelCase       )

							lowerCAmelCase__       =						"padme amidala taking a bath artwork, safe for work, no nudity"
							lowerCAmelCase__       =						2734971755
							lowerCAmelCase__       =						7

							lowerCAmelCase__       =						torch.manual_seed(__UpperCAmelCase       )
							lowerCAmelCase__       =						sd_pipe(
							    [prompt]		,    generator=__UpperCAmelCase		,    guidance_scale=__UpperCAmelCase		,    num_inference_steps=50		,    output_type="np"		,    width=512		,    height=512		,    sld_guidance_scale=0		,    )

							lowerCAmelCase__       =						output.images
							lowerCAmelCase__       =						image[0, -3:, -3:, -1]
							lowerCAmelCase__       =						[0.3_502, 0.3_622, 0.3_396, 0.3_642, 0.3_478, 0.3_318, 0.35, 0.3_348, 0.3_297]

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

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

							lowerCAmelCase__       =						torch.manual_seed(__UpperCAmelCase       )
							lowerCAmelCase__       =						sd_pipe(
							    [prompt]		,    generator=__UpperCAmelCase		,    guidance_scale=__UpperCAmelCase		,    num_inference_steps=50		,    output_type="np"		,    width=512		,    height=512		,    sld_guidance_scale=2000		,    sld_warmup_steps=7		,    sld_threshold=0.025		,    sld_momentum_scale=0.5		,    sld_mom_beta=0.7		,    )

							lowerCAmelCase__       =						output.images
							lowerCAmelCase__       =						image[0, -3:, -3:, -1]
							lowerCAmelCase__       =						[0.5_531, 0.5_206, 0.4_895, 0.5_156, 0.5_182, 0.4_751, 0.4_802, 0.4_803, 0.4_443]

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

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


	def 		UpperCAmelCase  (							self       )->					Optional[Any]:







							'''simple docstring'''





							lowerCAmelCase__       =						StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5"       )
							lowerCAmelCase__       =						sd_pipe.to(__UpperCAmelCase       )
							sd_pipe.set_progress_bar_config(disable=__UpperCAmelCase       )

							lowerCAmelCase__       =						(
							    "the four horsewomen of the apocalypse, painting by tom of finland, gaston bussiere, craig mullins, j. c."
							    " leyendecker"
							)
							lowerCAmelCase__       =						1044355234
							lowerCAmelCase__       =						12

							lowerCAmelCase__       =						torch.manual_seed(__UpperCAmelCase       )
							lowerCAmelCase__       =						sd_pipe(
							    [prompt]		,    generator=__UpperCAmelCase		,    guidance_scale=__UpperCAmelCase		,    num_inference_steps=50		,    output_type="np"		,    width=512		,    height=512		,    sld_guidance_scale=0		,    )

							lowerCAmelCase__       =						output.images
							lowerCAmelCase__       =						image[0, -3:, -3:, -1]
							lowerCAmelCase__       =						np.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]       )

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

							assert np.abs(image_slice.flatten() - expected_slice       ).max() < 1E-7

							lowerCAmelCase__       =						torch.manual_seed(__UpperCAmelCase       )
							lowerCAmelCase__       =						sd_pipe(
							    [prompt]		,    generator=__UpperCAmelCase		,    guidance_scale=__UpperCAmelCase		,    num_inference_steps=50		,    output_type="np"		,    width=512		,    height=512		,    sld_guidance_scale=2000		,    sld_warmup_steps=7		,    sld_threshold=0.025		,    sld_momentum_scale=0.5		,    sld_mom_beta=0.7		,    )

							lowerCAmelCase__       =						output.images
							lowerCAmelCase__       =						image[0, -3:, -3:, -1]
							lowerCAmelCase__       =						np.array([0.5_818, 0.6_285, 0.6_835, 0.6_019, 0.625, 0.6_754, 0.6_096, 0.6_334, 0.6_561]       )
							assert image.shape == (1, 512, 512, 3)

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














from __future__ import annotations

from collections.abc import Generator


def        _a  (     ) ->   Generator[int, None, None]:
						"""simple docstring"""







						lowerCAmelCase__       =						{}
						lowerCAmelCase__       =						2
						while True:
												lowerCAmelCase__       =						factor_map.pop(UpperCamelCase_    ,   UpperCamelCase_   )
												if factor:
																		lowerCAmelCase__       =						factor + prime
																		while x in factor_map:
																								x += factor
																		lowerCAmelCase__       =						factor
												else:
																		lowerCAmelCase__       =						prime
																		yield prime
												prime += 1


def        _a  (     UpperCamelCase_					:				float = 1e1_0   ) ->   int:
						"""simple docstring"""







						lowerCAmelCase__       =						sieve()

						lowerCAmelCase__       =						1
						while True:
												lowerCAmelCase__       =						next(UpperCamelCase_   )
												if (2 * prime * n) > limit:
																		return n
												# Ignore the next prime as the reminder will be 2.
												next(UpperCamelCase_   )
												n += 2


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






