





import gc
import unittest

import numpy as np
import torch

from diffusers import StableDiffusionKDiffusionPipeline
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()







@slow
@require_torch_gpu
class      lowerCamelCase(						unittest.TestCase	):
     '''simple docstring'''


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




     def        lowerCAmelCase__		(    self							):
         _A     =							StableDiffusionKDiffusionPipeline.from_pretrained('CompVis/stable-diffusion-v1-4'							)
         _A     =							sd_pipe.to(snake_case_							)
         sd_pipe.set_progress_bar_config(disable=snake_case_							)

         sd_pipe.set_scheduler('sample_euler'							)

         _A     =							'A painting of a squirrel eating a burger'
         _A     =							torch.manual_seed(0							)
         _A     =							sd_pipe([prompt]				,     generator=snake_case_				,     guidance_scale=9.0				,     num_inference_steps=20				,     output_type='np'							)

         _A     =							output.images

         _A     =							image[0, -3:, -3:, -1]

         assert image.shape == (1, 512, 512, 3)
         _A     =							np.array([0.0447, 0.0492, 0.0468, 0.0408, 0.0383, 0.0408, 0.0354, 0.0380, 0.0339]							)

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




     def        lowerCAmelCase__		(    self							):
         _A     =							StableDiffusionKDiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base'							)
         _A     =							sd_pipe.to(snake_case_							)
         sd_pipe.set_progress_bar_config(disable=snake_case_							)

         sd_pipe.set_scheduler('sample_euler'							)

         _A     =							'A painting of a squirrel eating a burger'
         _A     =							torch.manual_seed(0							)
         _A     =							sd_pipe([prompt]				,     generator=snake_case_				,     guidance_scale=9.0				,     num_inference_steps=20				,     output_type='np'							)

         _A     =							output.images

         _A     =							image[0, -3:, -3:, -1]

         assert image.shape == (1, 512, 512, 3)
         _A     =							np.array([0.1237, 0.1320, 0.1438, 0.1359, 0.1390, 0.1132, 0.1277, 0.1175, 0.1112]							)

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




     def        lowerCAmelCase__		(    self							):
         _A     =							StableDiffusionKDiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base'							)
         _A     =							sd_pipe.to(snake_case_							)
         sd_pipe.set_progress_bar_config(disable=snake_case_							)

         sd_pipe.set_scheduler('sample_dpmpp_2m'							)

         _A     =							'A painting of a squirrel eating a burger'
         _A     =							torch.manual_seed(0							)
         _A     =							sd_pipe(
             [prompt]				,     generator=snake_case_				,     guidance_scale=7.5				,     num_inference_steps=15				,     output_type='np'				,     use_karras_sigmas=snake_case_				,     )

         _A     =							output.images

         _A     =							image[0, -3:, -3:, -1]

         assert image.shape == (1, 512, 512, 3)
         _A     =							np.array(
             [0.1138_1689, 0.1211_2921, 0.138_9457, 0.1254_9606, 0.124_4964, 0.1083_1517, 0.1156_2866, 0.1086_7816, 0.1049_9048]							)

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












from __future__ import annotations

import math





def 				__lowerCAmelCase(       _SCREAMING_SNAKE_CASE				)							-> list[int]:




    """simple docstring"""




    if num <= 0:
        _A     =							F"{num}: Invalid input, please enter a positive integer."
        raise ValueError(_SCREAMING_SNAKE_CASE				)

    _A     =							[True] * (num + 1)
    _A     =							[]
    _A     =							2
    _A     =							int(math.sqrt(_SCREAMING_SNAKE_CASE				)				)

    while start <= end:
        # If start is a prime
        if sieve[start] is True:
            prime.append(_SCREAMING_SNAKE_CASE				)

            # Set multiples of start be False
            for i in range(start * start							,     num + 1							,     _SCREAMING_SNAKE_CASE				):
                if sieve[i] is True:
                    _A     =							False

        start += 1

    for j in range(end + 1							,     num + 1				):
        if sieve[j] is True:
            prime.append(_SCREAMING_SNAKE_CASE				)

    return prime


if __name__ == "__main__":
 print(prime_sieve(int(input("Enter a positive integer: ").strip())))





