'''simple docstring'''






import random
import unittest

import torch

from diffusers import IFImgaImgSuperResolutionPipeline
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    a (       __lowerCAmelCase						,  __lowerCAmelCase						,  unittest.TestCase				):



  """simple docstring"""
  __lowerCAmelCase				      =					IFImgaImgSuperResolutionPipeline
  __lowerCAmelCase				      =					TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {"""width""", """height"""}
  __lowerCAmelCase				      =					TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"""original_image"""}				)
  __lowerCAmelCase				      =					PipelineTesterMixin.required_optional_params - {"""latents"""}







  def    lowercase_  (							self					):

    '''simple docstring'''







    return self._get_superresolution_dummy_components()







  def    lowercase_  (							self   ,    snake_case_   ,    snake_case_=0					):

    '''simple docstring'''







    if str(snake_case_					).startswith("""mps"""					):
      __UpperCAmelCase:					List[str]		= torch.manual_seed(snake_case_					)
    else:
      __UpperCAmelCase:					int		= torch.Generator(device=snake_case_					).manual_seed(snake_case_					)

    __UpperCAmelCase:					Union[str, Any]		= floats_tensor((1, 3, 32, 32)   ,    rng=random.Random(snake_case_					)					).to(snake_case_					)
    __UpperCAmelCase:					Optional[Any]		= floats_tensor((1, 3, 16, 16)   ,    rng=random.Random(snake_case_					)					).to(snake_case_					)

    __UpperCAmelCase:					Optional[Any]		= {
        """prompt""": """A painting of a squirrel eating a burger""",
        """image""": image,
        """original_image""": original_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    lowercase_  (							self					):

    '''simple docstring'''







    self._test_xformers_attention_forwardGenerator_pass(expected_max_diff=1e-3					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    self._test_save_load_optional_components()







  @unittest.skipIf(torch_device != """cuda"""   ,    reason="""float16 requires CUDA"""					)
  def    lowercase_  (							self					):

    '''simple docstring'''







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







  def    lowercase_  (							self					):

    '''simple docstring'''







    self._test_attention_slicing_forward_pass(expected_max_diff=1e-2					)







  def    lowercase_  (							self					):

    '''simple docstring'''







    self._test_save_load_local()







  def    lowercase_  (							self					):

    '''simple docstring'''







    self._test_inference_batch_single_identical(
        expected_max_diff=1e-2   ,    )
'''simple docstring'''






import itertools
import math






def  UpperCamelCase__					(					_lowercase    :				int     )							->	bool:

  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  UpperCamelCase__					(					)							->	Optional[int]:
  __UpperCAmelCase:					Union[str, Any]		= 2
  while True:
    if is_prime(_lowercase     ):
      yield num
    num += 1






def  UpperCamelCase__					(					_lowercase    :				int = 1_0_0_0_1     )							->	int:
  return next(itertools.islice(prime_generator()   ,    nth - 1   ,    _lowercase     )     )


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