

'''simple docstring'''

import gc
import unittest

import numpy as np
import torch
from torch.backends.cuda import sdp_kernel

from diffusers import (
    CMStochasticIterativeScheduler,
    ConsistencyModelPipeline,
    UNetaDModel,
)
from diffusers.utils import randn_tensor, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_a, require_torch_gpu

from ..pipeline_params import UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS, UNCONDITIONAL_IMAGE_GENERATION_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()





class 							_snake_case (       _a	,  unittest.TestCase						):
   _A       :     int       =					ConsistencyModelPipeline
   _A       :     Optional[Any]       =					UNCONDITIONAL_IMAGE_GENERATION_PARAMS
   _A       :     Optional[Any]       =					UNCONDITIONAL_IMAGE_GENERATION_BATCH_PARAMS

   # Override required_optional_params to remove num_images_per_prompt
   _A       :     Any       =					frozenset(
       [
           '''num_inference_steps''',
           '''generator''',
           '''latents''',
           '''output_type''',
           '''return_dict''',
           '''callback''',
           '''callback_steps''',
       ]						)
   @property
   def     __UpperCamelCase						( self			:      Any							):
     SCREAMING_SNAKE_CASE:Optional[Any]						      =					UNetaDModel.from_pretrained(
         "diffusers/consistency-models-test"     ,subfolder="test_unet"     ,)
     return unet
   @property
   def     __UpperCamelCase						( self			:      Optional[int]							):
     SCREAMING_SNAKE_CASE:Union[str, Any]						      =					UNetaDModel.from_pretrained(
         "diffusers/consistency-models-test"     ,subfolder="test_unet_class_cond"     ,)
     return unet
   def     __UpperCamelCase						( self			:      str     ,SCREAMING_SNAKE_CASE__			:      Optional[Any]=False							):
     if class_cond:
       SCREAMING_SNAKE_CASE:List[Any]						      =					self.dummy_cond_unet
     else:
       SCREAMING_SNAKE_CASE:str						      =					self.dummy_uncond_unet

     # Default to CM multistep sampler
     SCREAMING_SNAKE_CASE:Optional[int]						      =					CMStochasticIterativeScheduler(
         num_train_timesteps=40     ,sigma_min=0.002     ,sigma_max=80.0     ,)

     SCREAMING_SNAKE_CASE:Any						      =					{
         "unet": unet,
         "scheduler": scheduler,
     }

     return components
   def     __UpperCamelCase						( self			:      Any     ,SCREAMING_SNAKE_CASE__			:      List[Any]     ,SCREAMING_SNAKE_CASE__			:      Optional[int]=0							):
     if str(SCREAMING_SNAKE_CASE__							).startswith("mps"							):
       SCREAMING_SNAKE_CASE:List[str]						      =					torch.manual_seed(SCREAMING_SNAKE_CASE__							)
     else:
       SCREAMING_SNAKE_CASE:Any						      =					torch.Generator(device=SCREAMING_SNAKE_CASE__							).manual_seed(SCREAMING_SNAKE_CASE__							)

     SCREAMING_SNAKE_CASE:str						      =					{
         "batch_size": 1,
         "num_inference_steps": None,
         "timesteps": [22, 0],
         "generator": generator,
         "output_type": "np",
     }

     return inputs
   def     __UpperCamelCase						( self			:      Any							):
     SCREAMING_SNAKE_CASE:int						      =					"cpu"  # ensure determinism for the device-dependent torch.Generator
     SCREAMING_SNAKE_CASE:Optional[Any]						      =					self.get_dummy_components()
     SCREAMING_SNAKE_CASE:Optional[int]						      =					ConsistencyModelPipeline(**SCREAMING_SNAKE_CASE__							)
     SCREAMING_SNAKE_CASE:str						      =					pipe.to(SCREAMING_SNAKE_CASE__							)
     pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__							)

     SCREAMING_SNAKE_CASE:Optional[Any]						      =					self.get_dummy_inputs(SCREAMING_SNAKE_CASE__							)
     SCREAMING_SNAKE_CASE:Any						      =					pipe(**SCREAMING_SNAKE_CASE__							).images
     assert image.shape == (1, 32, 32, 3)

     SCREAMING_SNAKE_CASE:List[Any]						      =					image[0, -3:, -3:, -1]
     SCREAMING_SNAKE_CASE:Union[str, Any]						      =					np.array([0.3_572, 0.6_273, 0.4_031, 0.3_961, 0.4_321, 0.5_730, 0.5_266, 0.4_780, 0.5_004]							)

     assert np.abs(image_slice.flatten() - expected_slice							).max() < 1e-3
   def     __UpperCamelCase						( self			:      Dict							):
     SCREAMING_SNAKE_CASE:Any						      =					"cpu"  # ensure determinism for the device-dependent torch.Generator
     SCREAMING_SNAKE_CASE:Dict						      =					self.get_dummy_components(class_cond=SCREAMING_SNAKE_CASE__							)
     SCREAMING_SNAKE_CASE:Optional[Any]						      =					ConsistencyModelPipeline(**SCREAMING_SNAKE_CASE__							)
     SCREAMING_SNAKE_CASE:Optional[Any]						      =					pipe.to(SCREAMING_SNAKE_CASE__							)
     pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__							)

     SCREAMING_SNAKE_CASE:List[Any]						      =					self.get_dummy_inputs(SCREAMING_SNAKE_CASE__							)
     SCREAMING_SNAKE_CASE:List[str]						      =					0
     SCREAMING_SNAKE_CASE:Any						      =					pipe(**SCREAMING_SNAKE_CASE__							).images
     assert image.shape == (1, 32, 32, 3)

     SCREAMING_SNAKE_CASE:Union[str, Any]						      =					image[0, -3:, -3:, -1]
     SCREAMING_SNAKE_CASE:Optional[int]						      =					np.array([0.3_572, 0.6_273, 0.4_031, 0.3_961, 0.4_321, 0.5_730, 0.5_266, 0.4_780, 0.5_004]							)

     assert np.abs(image_slice.flatten() - expected_slice							).max() < 1e-3
   def     __UpperCamelCase						( self			:      Tuple							):
     SCREAMING_SNAKE_CASE:str						      =					"cpu"  # ensure determinism for the device-dependent torch.Generator
     SCREAMING_SNAKE_CASE:int						      =					self.get_dummy_components()
     SCREAMING_SNAKE_CASE:Dict						      =					ConsistencyModelPipeline(**SCREAMING_SNAKE_CASE__							)
     SCREAMING_SNAKE_CASE:Dict						      =					pipe.to(SCREAMING_SNAKE_CASE__							)
     pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__							)

     SCREAMING_SNAKE_CASE:List[str]						      =					self.get_dummy_inputs(SCREAMING_SNAKE_CASE__							)
     SCREAMING_SNAKE_CASE:Optional[int]						      =					1
     SCREAMING_SNAKE_CASE:Tuple						      =					None
     SCREAMING_SNAKE_CASE:str						      =					pipe(**SCREAMING_SNAKE_CASE__							).images
     assert image.shape == (1, 32, 32, 3)

     SCREAMING_SNAKE_CASE:List[Any]						      =					image[0, -3:, -3:, -1]
     SCREAMING_SNAKE_CASE:List[str]						      =					np.array([0.5_004, 0.5_004, 0.4_994, 0.5_008, 0.4_976, 0.5_018, 0.4_990, 0.4_982, 0.4_987]							)

     assert np.abs(image_slice.flatten() - expected_slice							).max() < 1e-3







   def     __UpperCamelCase						( self			:      Tuple							):
     SCREAMING_SNAKE_CASE:Dict						      =					"cpu"  # ensure determinism for the device-dependent torch.Generator
     SCREAMING_SNAKE_CASE:Optional[int]						      =					self.get_dummy_components(class_cond=SCREAMING_SNAKE_CASE__							)
     SCREAMING_SNAKE_CASE:Dict						      =					ConsistencyModelPipeline(**SCREAMING_SNAKE_CASE__							)
     SCREAMING_SNAKE_CASE:Tuple						      =					pipe.to(SCREAMING_SNAKE_CASE__							)
     pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__							)

     SCREAMING_SNAKE_CASE:int						      =					self.get_dummy_inputs(SCREAMING_SNAKE_CASE__							)
     SCREAMING_SNAKE_CASE:List[str]						      =					1
     SCREAMING_SNAKE_CASE:Optional[int]						      =					None
     SCREAMING_SNAKE_CASE:Optional[int]						      =					0
     SCREAMING_SNAKE_CASE:Any						      =					pipe(**SCREAMING_SNAKE_CASE__							).images
     assert image.shape == (1, 32, 32, 3)

     SCREAMING_SNAKE_CASE:Optional[int]						      =					image[0, -3:, -3:, -1]
     SCREAMING_SNAKE_CASE:Any						      =					np.array([0.5_004, 0.5_004, 0.4_994, 0.5_008, 0.4_976, 0.5_018, 0.4_990, 0.4_982, 0.4_987]							)

     assert np.abs(image_slice.flatten() - expected_slice							).max() < 1e-3





@slow
@require_torch_gpu
class 							_snake_case (       unittest.TestCase						):
   def     __UpperCamelCase						( self			:      Optional[Any]							):
     super().tearDown()
     gc.collect()
     torch.cuda.empty_cache()
   def     __UpperCamelCase						( self			:      Tuple     ,SCREAMING_SNAKE_CASE__			:      Optional[Any]=0     ,SCREAMING_SNAKE_CASE__			:      Union[str, Any]=False     ,SCREAMING_SNAKE_CASE__			:      Optional[int]="cpu"     ,SCREAMING_SNAKE_CASE__			:      List[Any]=torch.floataa     ,SCREAMING_SNAKE_CASE__			:      Dict=(1, 3, 64, 64)							):
     SCREAMING_SNAKE_CASE:Optional[int]						      =					torch.manual_seed(SCREAMING_SNAKE_CASE__							)

     SCREAMING_SNAKE_CASE:List[Any]						      =					{
         "num_inference_steps": None,
         "timesteps": [22, 0],
         "class_labels": 0,
         "generator": generator,
         "output_type": "np",
     }

     if get_fixed_latents:
       SCREAMING_SNAKE_CASE:List[Any]						      =					self.get_fixed_latents(seed=SCREAMING_SNAKE_CASE__     ,device=SCREAMING_SNAKE_CASE__     ,dtype=SCREAMING_SNAKE_CASE__     ,shape=SCREAMING_SNAKE_CASE__							)
       SCREAMING_SNAKE_CASE:Optional[int]						      =					latents

     return inputs
   def     __UpperCamelCase						( self			:      Union[str, Any]     ,SCREAMING_SNAKE_CASE__			:      Tuple=0     ,SCREAMING_SNAKE_CASE__			:      Dict="cpu"     ,SCREAMING_SNAKE_CASE__			:      Tuple=torch.floataa     ,SCREAMING_SNAKE_CASE__			:      List[Any]=(1, 3, 64, 64)							):
     if type(SCREAMING_SNAKE_CASE__							) == str:
       SCREAMING_SNAKE_CASE:List[Any]						      =					torch.device(SCREAMING_SNAKE_CASE__							)
     SCREAMING_SNAKE_CASE:Any						      =					torch.Generator(device=SCREAMING_SNAKE_CASE__							).manual_seed(SCREAMING_SNAKE_CASE__							)
     SCREAMING_SNAKE_CASE:List[Any]						      =					randn_tensor(SCREAMING_SNAKE_CASE__     ,generator=SCREAMING_SNAKE_CASE__     ,device=SCREAMING_SNAKE_CASE__     ,dtype=SCREAMING_SNAKE_CASE__							)
     return latents
   def     __UpperCamelCase						( self			:      Tuple							):
     SCREAMING_SNAKE_CASE:Dict						      =					UNetaDModel.from_pretrained("diffusers/consistency_models"     ,subfolder="diffusers_cd_imagenet64_l2"							)
     SCREAMING_SNAKE_CASE:List[Any]						      =					CMStochasticIterativeScheduler(
         num_train_timesteps=40     ,sigma_min=0.002     ,sigma_max=80.0     ,)
     SCREAMING_SNAKE_CASE:Any						      =					ConsistencyModelPipeline(unet=SCREAMING_SNAKE_CASE__     ,scheduler=SCREAMING_SNAKE_CASE__							)
     pipe.to(torch_device=SCREAMING_SNAKE_CASE__							)
     pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__							)

     SCREAMING_SNAKE_CASE:List[Any]						      =					self.get_inputs()
     SCREAMING_SNAKE_CASE:int						      =					pipe(**SCREAMING_SNAKE_CASE__							).images
     assert image.shape == (1, 64, 64, 3)

     SCREAMING_SNAKE_CASE:str						      =					image[0, -3:, -3:, -1]

     SCREAMING_SNAKE_CASE:Tuple						      =					np.array([0.0_888, 0.0_881, 0.0_666, 0.0_479, 0.0_292, 0.0_195, 0.0_201, 0.0_163, 0.0_254]							)

     assert np.abs(image_slice.flatten() - expected_slice							).max() < 2e-2
   def     __UpperCamelCase						( self			:      str							):
     SCREAMING_SNAKE_CASE:Optional[Any]						      =					UNetaDModel.from_pretrained("diffusers/consistency_models"     ,subfolder="diffusers_cd_imagenet64_l2"							)
     SCREAMING_SNAKE_CASE:Any						      =					CMStochasticIterativeScheduler(
         num_train_timesteps=40     ,sigma_min=0.002     ,sigma_max=80.0     ,)
     SCREAMING_SNAKE_CASE:Tuple						      =					ConsistencyModelPipeline(unet=SCREAMING_SNAKE_CASE__     ,scheduler=SCREAMING_SNAKE_CASE__							)
     pipe.to(torch_device=SCREAMING_SNAKE_CASE__							)
     pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__							)

     SCREAMING_SNAKE_CASE:List[Any]						      =					self.get_inputs()
     SCREAMING_SNAKE_CASE:Union[str, Any]						      =					1
     SCREAMING_SNAKE_CASE:str						      =					None
     SCREAMING_SNAKE_CASE:Dict						      =					pipe(**SCREAMING_SNAKE_CASE__							).images
     assert image.shape == (1, 64, 64, 3)

     SCREAMING_SNAKE_CASE:List[Any]						      =					image[0, -3:, -3:, -1]

     SCREAMING_SNAKE_CASE:Tuple						      =					np.array([0.0_340, 0.0_152, 0.0_063, 0.0_267, 0.0_221, 0.0_107, 0.0_416, 0.0_186, 0.0_217]							)

     assert np.abs(image_slice.flatten() - expected_slice							).max() < 2e-2
   @require_torch_a
   def     __UpperCamelCase						( self			:      Dict							):
     SCREAMING_SNAKE_CASE:List[Any]						      =					UNetaDModel.from_pretrained("diffusers/consistency_models"     ,subfolder="diffusers_cd_imagenet64_l2"							)
     SCREAMING_SNAKE_CASE:Optional[int]						      =					CMStochasticIterativeScheduler(
         num_train_timesteps=40     ,sigma_min=0.002     ,sigma_max=80.0     ,)
     SCREAMING_SNAKE_CASE:int						      =					ConsistencyModelPipeline(unet=SCREAMING_SNAKE_CASE__     ,scheduler=SCREAMING_SNAKE_CASE__							)
     pipe.to(torch_device=SCREAMING_SNAKE_CASE__     ,torch_dtype=torch.floataa							)
     pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__							)

     SCREAMING_SNAKE_CASE:Tuple						      =					self.get_inputs(get_fixed_latents=SCREAMING_SNAKE_CASE__     ,device=SCREAMING_SNAKE_CASE__							)
     # Ensure usage of flash attention in torch 2.0
     with sdp_kernel(enable_flash=SCREAMING_SNAKE_CASE__     ,enable_math=SCREAMING_SNAKE_CASE__     ,enable_mem_efficient=SCREAMING_SNAKE_CASE__							):
       SCREAMING_SNAKE_CASE:List[str]						      =					pipe(**SCREAMING_SNAKE_CASE__							).images
     assert image.shape == (1, 64, 64, 3)

     SCREAMING_SNAKE_CASE:Dict						      =					image[0, -3:, -3:, -1]

     SCREAMING_SNAKE_CASE:List[str]						      =					np.array([0.1_875, 0.1_428, 0.1_289, 0.2_151, 0.2_092, 0.1_477, 0.1_877, 0.1_641, 0.1_353]							)

     assert np.abs(image_slice.flatten() - expected_slice							).max() < 1e-3







   @require_torch_a
   def     __UpperCamelCase						( self			:      List[str]							):
     SCREAMING_SNAKE_CASE:Union[str, Any]						      =					UNetaDModel.from_pretrained("diffusers/consistency_models"     ,subfolder="diffusers_cd_imagenet64_l2"							)
     SCREAMING_SNAKE_CASE:Dict						      =					CMStochasticIterativeScheduler(
         num_train_timesteps=40     ,sigma_min=0.002     ,sigma_max=80.0     ,)
     SCREAMING_SNAKE_CASE:List[Any]						      =					ConsistencyModelPipeline(unet=SCREAMING_SNAKE_CASE__     ,scheduler=SCREAMING_SNAKE_CASE__							)
     pipe.to(torch_device=SCREAMING_SNAKE_CASE__     ,torch_dtype=torch.floataa							)
     pipe.set_progress_bar_config(disable=SCREAMING_SNAKE_CASE__							)

     SCREAMING_SNAKE_CASE:Optional[int]						      =					self.get_inputs(get_fixed_latents=SCREAMING_SNAKE_CASE__     ,device=SCREAMING_SNAKE_CASE__							)
     SCREAMING_SNAKE_CASE:Union[str, Any]						      =					1
     SCREAMING_SNAKE_CASE:Optional[int]						      =					None
     # Ensure usage of flash attention in torch 2.0
     with sdp_kernel(enable_flash=SCREAMING_SNAKE_CASE__     ,enable_math=SCREAMING_SNAKE_CASE__     ,enable_mem_efficient=SCREAMING_SNAKE_CASE__							):
       SCREAMING_SNAKE_CASE:List[str]						      =					pipe(**SCREAMING_SNAKE_CASE__							).images
     assert image.shape == (1, 64, 64, 3)

     SCREAMING_SNAKE_CASE:Tuple						      =					image[0, -3:, -3:, -1]

     SCREAMING_SNAKE_CASE:List[Any]						      =					np.array([0.1_663, 0.1_948, 0.2_275, 0.1_680, 0.1_204, 0.1_245, 0.1_858, 0.1_338, 0.2_095]							)

     assert np.abs(image_slice.flatten() - expected_slice							).max() < 1e-3



'''simple docstring'''

def    A_  ( snake_case ):
  SCREAMING_SNAKE_CASE:Dict						      =					(1 + 24 * n) ** 0.5
  return ((1 + root) / 6) % 1 == 0





def    A_  ( snake_case = 5000 ):
  SCREAMING_SNAKE_CASE:int						      =					[(i * (3 * i - 1)) // 2 for i in range(1      ,       snake_case )]
  for i, pentagonal_i in enumerate(snake_case ):
    for j in range(snake_case      ,       len(snake_case ) ):
      SCREAMING_SNAKE_CASE:int						      =					pentagonal_nums[j]
      SCREAMING_SNAKE_CASE:Any						      =					pentagonal_i + pentagonal_j
      SCREAMING_SNAKE_CASE:int						      =					pentagonal_j - pentagonal_i
      if is_pentagonal(snake_case ) and is_pentagonal(snake_case ):
        return b

  return -1


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






