


import random
import unittest

import torch

from diffusers import IFSuperResolutionPipeline
from diffusers.utils import floats_tensor
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import skip_mps, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS, TEXT_GUIDED_IMAGE_VARIATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin
from . import IFPipelineTesterMixin



@skip_mps
class 					__lowerCamelCase	(_a							,     _a							,     unittest.TestCase		):
       _lowercase    							=      IFSuperResolutionPipeline
       _lowercase    							=      TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""width""", """height"""}
       _lowercase    							=      TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
       _lowercase    							=      PipelineTesterMixin.required_optional_params - {"""latents"""}







       def 						snake_case_					(	self:				Optional[Any]			):






            '''simple docstring'''




            return self._get_superresolution_dummy_components()







       def 						snake_case_					(	self:				Dict,A_:				Dict,A_:				Union[str, Any]=0			):






            '''simple docstring'''




            if str(A_			).startswith('mps'			):
                 __UpperCamelCase				=	torch.manual_seed(A_			)
            else:
                 __UpperCamelCase				=	torch.Generator(device=A_			).manual_seed(A_			)

            __UpperCamelCase				=	floats_tensor((1, 3, 32, 32),rng=random.Random(A_			)			).to(A_			)

            __UpperCamelCase				=	{
                'prompt': 'A painting of a squirrel eating a burger',
                'image': image,
                'generator': generator,
                'num_inference_steps': 2,
                'output_type': 'numpy',
            }

            return inputs







       @unittest.skipIf(
           torch_device != 'cuda' or not is_xformers_available(),reason='XFormers attention is only available with CUDA and `xformers` installed',)
       def 						snake_case_					(	self:				List[Any]			):






            '''simple docstring'''




            self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1E-3			)







       def 						snake_case_					(	self:				int			):






            '''simple docstring'''




            self._test_save_load_optional_components()







       @unittest.skipIf(torch_device != 'cuda',reason='float16 requires CUDA'			)
       def 						snake_case_					(	self:				Any			):






            '''simple docstring'''




            super().test_save_load_floataa(expected_max_diff=1E-1			)







       def 						snake_case_					(	self:				Optional[int]			):






            '''simple docstring'''




            self._test_attention_slicing_forward_pass(expected_max_diff=1E-2			)







       def 						snake_case_					(	self:				str			):






            '''simple docstring'''




            self._test_save_load_local()







       def 						snake_case_					(	self:				Any			):






            '''simple docstring'''




            self._test_inference_batch_single_identical(
                expected_max_diff=1E-2,)






import math






def 						_A						(						_lowercase				)			->				bool:


     """simple docstring"""


     if 1 < number < 4:
          # 2 and 3 are primes
          return True
     elif number < 2 or number % 2 == 0 or number % 3 == 0:
          # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
          return False

     # All primes number are in format of 6k +/- 1
     for i in range(5			,       int(math.sqrt(_lowercase				) + 1				)			,       6				):
          if number % i == 0 or number % (i + 2) == 0:
               return False
     return True






def 						_A						(						_lowercase = 2_00_00_00				)			->				int:


     """simple docstring"""


     return sum(num for num in range(3			,       _lowercase			,       2				) if is_prime(_lowercase				)				) + 2 if n > 2 else 0


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


