




def 						SCREAMING_SNAKE_CASE__ (   lowercase = 1000					)  ->       int:
   snake_case				:    Optional[int]           =	3
   snake_case				:    List[Any]           =	0
   while a < n:
      if a % 3 == 0 or a % 5 == 0:
         result += a
      elif a % 15 == 0:
         result -= a
      a += 1
   return result


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











import gc
import random
import unittest

import torch

from diffusers import (
    IFImgaImgPipeline,
    IFImgaImgSuperResolutionPipeline,
    IFInpaintingPipeline,
    IFInpaintingSuperResolutionPipeline,
    IFPipeline,
    IFSuperResolutionPipeline,
)
from diffusers.models.attention_processor import AttnAddedKVProcessor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import floats_tensor, load_numpy, require_torch_gpu, skip_mps, slow, torch_device

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference
from . import IFPipelineTesterMixin




@skip_mps
class 						__lowercase		(UpperCamelCase__					,		UpperCamelCase__					,		unittest.TestCase							):




      """simple docstring"""





      _snake_case												=						IFPipeline
      _snake_case												=						TEXT_TO_IMAGE_PARAMS - {"""width""", """height""", """latents"""}
      _snake_case												=						TEXT_TO_IMAGE_BATCH_PARAMS
      _snake_case												=						PipelineTesterMixin.required_optional_params - {"""latents"""}

      def      UpperCAmelCase				(				self     )		->    Any:
         return self._get_dummy_components()

      def      UpperCAmelCase				(				self    ,				A    ,				A=0     )		->    Optional[int]:
         if str(A     ).startswith("""mps"""     ):
            snake_case				:    List[str]           =	torch.manual_seed(A     )
         else:
            snake_case				:    Optional[int]           =	torch.Generator(device=A     ).manual_seed(A     )

         snake_case				:    Optional[int]           =	{
             """prompt""": """A painting of a squirrel eating a burger""",
             """generator""": generator,
             """num_inference_steps""": 2,
             """output_type""": """numpy""",
         }

         return inputs

      def      UpperCAmelCase				(				self     )		->    Any:
         self._test_save_load_optional_components()

      @unittest.skipIf(torch_device != """cuda"""    ,				reason="""float16 requires CUDA"""     )
      def      UpperCAmelCase				(				self     )		->    List[str]:
         # Due to non-determinism in save load of the hf-internal-testing/tiny-random-t5 text encoder
         super().test_save_load_floataa(expected_max_diff=1e-1     )

      def      UpperCAmelCase				(				self     )		->    Dict:
         self._test_attention_slicing_forward_pass(expected_max_diff=1e-2     )

      def      UpperCAmelCase				(				self     )		->    List[str]:
         self._test_save_load_local()

      def      UpperCAmelCase				(				self     )		->    List[str]:
         self._test_inference_batch_single_identical(
             expected_max_diff=1e-2    ,				)

      @unittest.skipIf(
          torch_device != """cuda""" or not is_xformers_available()    ,				reason="""XFormers attention is only available with CUDA and `xformers` installed"""    ,				)
      def      UpperCAmelCase				(				self     )		->    List[str]:
         self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3     )




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




      """simple docstring"""





      def      UpperCAmelCase				(				self     )		->    Any:
         # clean up the VRAM after each test
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()

      def      UpperCAmelCase				(				self     )		->    List[Any]:
         # if

         snake_case				:    Tuple           =	IFPipeline.from_pretrained("""DeepFloyd/IF-I-XL-v1.0"""    ,				variant="""fp16"""    ,				torch_dtype=torch.floataa     )

         snake_case				:    Tuple           =	IFSuperResolutionPipeline.from_pretrained(
             """DeepFloyd/IF-II-L-v1.0"""    ,				variant="""fp16"""    ,				torch_dtype=torch.floataa    ,				text_encoder=A    ,				tokenizer=A     )

         # pre compute text embeddings and remove T5 to save memory

         pipe_a.text_encoder.to("""cuda"""     )

         snake_case     , snake_case				:    Optional[int]           =	pipe_a.encode_prompt("""anime turtle"""    ,				device="""cuda"""     )

         del pipe_a.tokenizer
         del pipe_a.text_encoder
         gc.collect()

         snake_case				:    List[str]           =	None
         snake_case				:    List[Any]           =	None

         pipe_a.enable_model_cpu_offload()
         pipe_a.enable_model_cpu_offload()

         pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()     )
         pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()     )

         self._test_if(A    ,				A    ,				A    ,				A     )

         pipe_a.remove_all_hooks()
         pipe_a.remove_all_hooks()

         # img2img

         snake_case				:    Any           =	IFImgaImgPipeline(**pipe_a.components     )
         snake_case				:    Dict           =	IFImgaImgSuperResolutionPipeline(**pipe_a.components     )

         pipe_a.enable_model_cpu_offload()
         pipe_a.enable_model_cpu_offload()

         pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()     )
         pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()     )

         self._test_if_imgaimg(A    ,				A    ,				A    ,				A     )

         pipe_a.remove_all_hooks()
         pipe_a.remove_all_hooks()

         # inpainting

         snake_case				:    Optional[Any]           =	IFInpaintingPipeline(**pipe_a.components     )
         snake_case				:    Any           =	IFInpaintingSuperResolutionPipeline(**pipe_a.components     )

         pipe_a.enable_model_cpu_offload()
         pipe_a.enable_model_cpu_offload()

         pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()     )
         pipe_a.unet.set_attn_processor(AttnAddedKVProcessor()     )

         self._test_if_inpainting(A    ,				A    ,				A    ,				A     )

      def      UpperCAmelCase				(				self    ,				A    ,				A    ,				A    ,				A     )		->    str:
         # pipeline 1

         _start_torch_memory_measurement()

         snake_case				:    Tuple           =	torch.Generator(device="""cpu"""     ).manual_seed(0     )
         snake_case				:    Tuple           =	pipe_a(
             prompt_embeds=A    ,				negative_prompt_embeds=A    ,				num_inference_steps=2    ,				generator=A    ,				output_type="""np"""    ,				)

         snake_case				:    Optional[int]           =	output.images[0]

         assert image.shape == (6_4, 6_4, 3)

         snake_case				:    Tuple           =	torch.cuda.max_memory_allocated()
         assert mem_bytes < 1_3 * 1_0**9

         snake_case				:    Dict           =	load_numpy(
             """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if.npy"""     )
         assert_mean_pixel_difference(A    ,				A     )

         # pipeline 2

         _start_torch_memory_measurement()

         snake_case				:    List[Any]           =	torch.Generator(device="""cpu"""     ).manual_seed(0     )

         snake_case				:    Optional[int]           =	floats_tensor((1, 3, 6_4, 6_4)    ,				rng=random.Random(0     )     ).to(A     )

         snake_case				:    str           =	pipe_a(
             prompt_embeds=A    ,				negative_prompt_embeds=A    ,				image=A    ,				generator=A    ,				num_inference_steps=2    ,				output_type="""np"""    ,				)

         snake_case				:    str           =	output.images[0]

         assert image.shape == (2_5_6, 2_5_6, 3)

         snake_case				:    Any           =	torch.cuda.max_memory_allocated()
         assert mem_bytes < 4 * 1_0**9

         snake_case				:    int           =	load_numpy(
             """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_superresolution_stage_II.npy"""     )
         assert_mean_pixel_difference(A    ,				A     )

      def      UpperCAmelCase				(				self    ,				A    ,				A    ,				A    ,				A     )		->    int:
         # pipeline 1

         _start_torch_memory_measurement()

         snake_case				:    Optional[Any]           =	floats_tensor((1, 3, 6_4, 6_4)    ,				rng=random.Random(0     )     ).to(A     )

         snake_case				:    List[str]           =	torch.Generator(device="""cpu"""     ).manual_seed(0     )

         snake_case				:    Union[str, Any]           =	pipe_a(
             prompt_embeds=A    ,				negative_prompt_embeds=A    ,				image=A    ,				num_inference_steps=2    ,				generator=A    ,				output_type="""np"""    ,				)

         snake_case				:    Optional[int]           =	output.images[0]

         assert image.shape == (6_4, 6_4, 3)

         snake_case				:    Tuple           =	torch.cuda.max_memory_allocated()
         assert mem_bytes < 1_0 * 1_0**9

         snake_case				:    Union[str, Any]           =	load_numpy(
             """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img.npy"""     )
         assert_mean_pixel_difference(A    ,				A     )

         # pipeline 2

         _start_torch_memory_measurement()

         snake_case				:    int           =	torch.Generator(device="""cpu"""     ).manual_seed(0     )

         snake_case				:    int           =	floats_tensor((1, 3, 2_5_6, 2_5_6)    ,				rng=random.Random(0     )     ).to(A     )
         snake_case				:    Optional[Any]           =	floats_tensor((1, 3, 6_4, 6_4)    ,				rng=random.Random(0     )     ).to(A     )

         snake_case				:    int           =	pipe_a(
             prompt_embeds=A    ,				negative_prompt_embeds=A    ,				image=A    ,				original_image=A    ,				generator=A    ,				num_inference_steps=2    ,				output_type="""np"""    ,				)

         snake_case				:    List[Any]           =	output.images[0]

         assert image.shape == (2_5_6, 2_5_6, 3)

         snake_case				:    Tuple           =	torch.cuda.max_memory_allocated()
         assert mem_bytes < 4 * 1_0**9

         snake_case				:    Any           =	load_numpy(
             """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_img2img_superresolution_stage_II.npy"""     )
         assert_mean_pixel_difference(A    ,				A     )

      def      UpperCAmelCase				(				self    ,				A    ,				A    ,				A    ,				A     )		->    Any:
         # pipeline 1

         _start_torch_memory_measurement()

         snake_case				:    List[Any]           =	floats_tensor((1, 3, 6_4, 6_4)    ,				rng=random.Random(0     )     ).to(A     )
         snake_case				:    Union[str, Any]           =	floats_tensor((1, 3, 6_4, 6_4)    ,				rng=random.Random(1     )     ).to(A     )

         snake_case				:    Dict           =	torch.Generator(device="""cpu"""     ).manual_seed(0     )
         snake_case				:    Tuple           =	pipe_a(
             prompt_embeds=A    ,				negative_prompt_embeds=A    ,				image=A    ,				mask_image=A    ,				num_inference_steps=2    ,				generator=A    ,				output_type="""np"""    ,				)

         snake_case				:    Tuple           =	output.images[0]

         assert image.shape == (6_4, 6_4, 3)

         snake_case				:    List[str]           =	torch.cuda.max_memory_allocated()
         assert mem_bytes < 1_0 * 1_0**9

         snake_case				:    Dict           =	load_numpy(
             """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting.npy"""     )
         assert_mean_pixel_difference(A    ,				A     )

         # pipeline 2

         _start_torch_memory_measurement()

         snake_case				:    Optional[int]           =	torch.Generator(device="""cpu"""     ).manual_seed(0     )

         snake_case				:    int           =	floats_tensor((1, 3, 6_4, 6_4)    ,				rng=random.Random(0     )     ).to(A     )
         snake_case				:    Any           =	floats_tensor((1, 3, 2_5_6, 2_5_6)    ,				rng=random.Random(0     )     ).to(A     )
         snake_case				:    str           =	floats_tensor((1, 3, 2_5_6, 2_5_6)    ,				rng=random.Random(1     )     ).to(A     )

         snake_case				:    List[str]           =	pipe_a(
             prompt_embeds=A    ,				negative_prompt_embeds=A    ,				image=A    ,				mask_image=A    ,				original_image=A    ,				generator=A    ,				num_inference_steps=2    ,				output_type="""np"""    ,				)

         snake_case				:    List[Any]           =	output.images[0]

         assert image.shape == (2_5_6, 2_5_6, 3)

         snake_case				:    Union[str, Any]           =	torch.cuda.max_memory_allocated()
         assert mem_bytes < 4 * 1_0**9

         snake_case				:    str           =	load_numpy(
             """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/if/test_if_inpainting_superresolution_stage_II.npy"""     )
         assert_mean_pixel_difference(A    ,				A     )




def 						SCREAMING_SNAKE_CASE__ (   )  ->       str:
   torch.cuda.empty_cache()
   torch.cuda.reset_max_memory_allocated()
   torch.cuda.reset_peak_memory_stats()





