




import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel

from diffusers import DDIMScheduler, LDMPipeline, UNetaDModel, VQModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()

class   __a(					unittest.TestCase       ):






    """simple docstring"""





    @property
    def 							a__				(				self  )			->		str:
         torch.manual_seed(0  )
         UpperCAmelCase_      :							List[str]       =      UNetaDModel(
             block_out_channels=(32, 64)       ,layers_per_block=2       ,sample_size=32       ,in_channels=3       ,out_channels=3       ,down_block_types=('''DownBlock2D''', '''AttnDownBlock2D''')       ,up_block_types=('''AttnUpBlock2D''', '''UpBlock2D''')       ,)
         return model





    @property
    def 							a__				(				self  )			->		Optional[Any]:
         torch.manual_seed(0  )
         UpperCAmelCase_      :							int       =      VQModel(
             block_out_channels=[32, 64]       ,in_channels=3       ,out_channels=3       ,down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']       ,up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']       ,latent_channels=3       ,)
         return model





    @property
    def 							a__				(				self  )			->		Union[str, Any]:
         torch.manual_seed(0  )
         UpperCAmelCase_      :							Optional[Any]       =      CLIPTextConfig(
             bos_token_id=0       ,eos_token_id=2       ,hidden_size=32       ,intermediate_size=37       ,layer_norm_eps=1e-05       ,num_attention_heads=4       ,num_hidden_layers=5       ,pad_token_id=1       ,vocab_size=1_000       ,)
         return CLIPTextModel(_SCREAMING_SNAKE_CASE  )





    def 							a__				(				self  )			->		List[Any]:
         UpperCAmelCase_      :							Tuple       =      self.dummy_uncond_unet
         UpperCAmelCase_      :							Optional[int]       =      DDIMScheduler()
         UpperCAmelCase_      :							Tuple       =      self.dummy_vq_model

         UpperCAmelCase_      :							str       =      LDMPipeline(unet=_SCREAMING_SNAKE_CASE       ,vqvae=_SCREAMING_SNAKE_CASE       ,scheduler=_SCREAMING_SNAKE_CASE  )
         ldm.to(_SCREAMING_SNAKE_CASE  )
         ldm.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE  )

         UpperCAmelCase_      :							Tuple       =      torch.manual_seed(0  )
         UpperCAmelCase_      :							List[str]       =      ldm(generator=_SCREAMING_SNAKE_CASE       ,num_inference_steps=2       ,output_type='''numpy'''  ).images

         UpperCAmelCase_      :							Dict       =      torch.manual_seed(0  )
         UpperCAmelCase_      :							Optional[Any]       =      ldm(generator=_SCREAMING_SNAKE_CASE       ,num_inference_steps=2       ,output_type='''numpy'''       ,return_dict=_SCREAMING_SNAKE_CASE  )[0]

         UpperCAmelCase_      :							int       =      image[0, -3:, -3:, -1]
         UpperCAmelCase_      :							str       =      image_from_tuple[0, -3:, -3:, -1]

         assert image.shape == (1, 64, 64, 3)
         UpperCAmelCase_      :							Dict       =      np.array([0.85_12, 0.8_18, 0.64_11, 0.68_08, 0.44_65, 0.56_18, 0.46, 0.62_31, 0.51_72]  )
         UpperCAmelCase_      :							Optional[Any]       =      1e-2 if torch_device != '''mps''' else 3e-2

         assert np.abs(image_slice.flatten() - expected_slice  ).max() < tolerance
         assert np.abs(image_from_tuple_slice.flatten() - expected_slice  ).max() < tolerance


@slow
@require_torch
class   __a(					unittest.TestCase       ):






    """simple docstring"""





    def 							a__				(				self  )			->		List[Any]:
         UpperCAmelCase_      :							Optional[Any]       =      LDMPipeline.from_pretrained('''CompVis/ldm-celebahq-256'''  )
         ldm.to(_SCREAMING_SNAKE_CASE  )
         ldm.set_progress_bar_config(disable=_SCREAMING_SNAKE_CASE  )

         UpperCAmelCase_      :							Optional[int]       =      torch.manual_seed(0  )
         UpperCAmelCase_      :							List[str]       =      ldm(generator=_SCREAMING_SNAKE_CASE       ,num_inference_steps=5       ,output_type='''numpy'''  ).images

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

         assert image.shape == (1, 256, 256, 3)
         UpperCAmelCase_      :							List[Any]       =      np.array([0.43_99, 0.4_49_75, 0.4_68_25, 0.4_74, 0.43_59, 0.45_81, 0.4_50_95, 0.43_41, 0.44_47]  )
         UpperCAmelCase_      :							Tuple       =      1e-2 if torch_device != '''mps''' else 3e-2

         assert np.abs(image_slice.flatten() - expected_slice  ).max() < tolerance





from math import ceil







def lowerCamelCase__       (      _lowercase = 1001				):

     '''simple docstring'''


     UpperCAmelCase_      :							Optional[Any]       =      1

     for i in range(1			,						int(ceil(n / 2.0				)				)				):
          UpperCAmelCase_      :							List[Any]       =      2 * i + 1
          UpperCAmelCase_      :							Optional[int]       =      2 * i
          UpperCAmelCase_      :							Any       =      total + 4 * odd**2 - 6 * even

     return total


if __name__ == "__main__":
     import sys

     if len(sys.argv) == 1:
          print(solution())
     else:
          try:
               __a          =			int(sys.argv[1])
               print(solution(n))
          except ValueError:
               print('Invalid entry - please enter a number')