import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPImageProcessor, CLIPVisionConfig, CLIPVisionModel

from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEImgaImgPipeline
from diffusers.pipelines.shap_e import ShapERenderer
from diffusers.utils import floats_tensor, load_image, load_numpy, slow
from diffusers.utils.testing_utils import require_torch_gpu, torch_device

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference







class 			lowercase    (	_lowerCAmelCase     ,  unittest.TestCase      ):
				__SCREAMING_SNAKE_CASE :			Union[str, Any]	      =      ShapEImgaImgPipeline
				__SCREAMING_SNAKE_CASE :			str	      =      ["image"]
				__SCREAMING_SNAKE_CASE :			Any	      =      ["image"]
				__SCREAMING_SNAKE_CASE :			List[Any]	      =      [
				    "num_images_per_prompt",
				    "num_inference_steps",
				    "generator",
				    "latents",
				    "guidance_scale",
				    "frame_size",
				    "output_type",
				    "return_dict",
				]
				__SCREAMING_SNAKE_CASE :			Optional[Any]	      =      False




				@property
				def    a							( self	):
											return 32




				@property
				def    a							( self	):
											return 32




				@property
				def    a							( self	):
											return self.time_input_dim * 4




				@property
				def    a							( self	):
											return 8




				@property
				def    a							( self	):
											torch.manual_seed(0	)
											snake_case_          =   CLIPVisionConfig(
											    hidden_size=self.text_embedder_hidden_size				,       image_size=64				,       projection_dim=self.text_embedder_hidden_size				,       intermediate_size=37				,       num_attention_heads=4				,       num_channels=3				,       num_hidden_layers=5				,       patch_size=1				,       )

											snake_case_          =   CLIPVisionModel(_lowercase	)
											return model




				@property
				def    a							( self	):
											snake_case_          =   CLIPImageProcessor(
											    crop_size=224				,       do_center_crop=_lowercase				,       do_normalize=_lowercase				,       do_resize=_lowercase				,       image_mean=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73]				,       image_std=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11]				,       resample=3				,       size=224				,       )

											return image_processor




				@property
				def    a							( self	):
											torch.manual_seed(0	)

											snake_case_          =   {
											    'num_attention_heads': 2,
											    'attention_head_dim': 16,
											    'embedding_dim': self.time_input_dim,
											    'num_embeddings': 32,
											    'embedding_proj_dim': self.text_embedder_hidden_size,
											    'time_embed_dim': self.time_embed_dim,
											    'num_layers': 1,
											    'clip_embed_dim': self.time_input_dim * 2,
											    'additional_embeddings': 0,
											    'time_embed_act_fn': 'gelu',
											    'norm_in_type': 'layer',
											    'embedding_proj_norm_type': 'layer',
											    'encoder_hid_proj_type': None,
											    'added_emb_type': None,
											}

											snake_case_          =   PriorTransformer(**_lowercase	)
											return model




				@property
				def    a							( self	):
											torch.manual_seed(0	)

											snake_case_          =   {
											    'param_shapes': (
											        (self.renderer_dim, 93),
											        (self.renderer_dim, 8),
											        (self.renderer_dim, 8),
											        (self.renderer_dim, 8),
											    ),
											    'd_latent': self.time_input_dim,
											    'd_hidden': self.renderer_dim,
											    'n_output': 12,
											    'background': (
											        0.1,
											        0.1,
											        0.1,
											    ),
											}
											snake_case_          =   ShapERenderer(**_lowercase	)
											return model




				def    a							( self	):
											snake_case_          =   self.dummy_prior
											snake_case_          =   self.dummy_image_encoder
											snake_case_          =   self.dummy_image_processor
											snake_case_          =   self.dummy_renderer

											snake_case_          =   HeunDiscreteScheduler(
											    beta_schedule='exp'				,       num_train_timesteps=1024				,       prediction_type='sample'				,       use_karras_sigmas=_lowercase				,       clip_sample=_lowercase				,       clip_sample_range=1.0				,       )
											snake_case_          =   {
											    'prior': prior,
											    'image_encoder': image_encoder,
											    'image_processor': image_processor,
											    'renderer': renderer,
											    'scheduler': scheduler,
											}

											return components




				def    a							( self				,       snake_case				,       snake_case=0	):
											snake_case_          =   floats_tensor((1, 3, 64, 64)				,       rng=random.Random(_lowercase	)	).to(_lowercase	)

											if str(_lowercase	).startswith('mps'	):
																		snake_case_          =   torch.manual_seed(_lowercase	)
											else:
																		snake_case_          =   torch.Generator(device=_lowercase	).manual_seed(_lowercase	)
											snake_case_          =   {
											    'image': input_image,
											    'generator': generator,
											    'num_inference_steps': 1,
											    'frame_size': 32,
											    'output_type': 'np',
											}
											return inputs




				def    a							( self	):
											snake_case_          =   'cpu'

											snake_case_          =   self.get_dummy_components()

											snake_case_          =   self.pipeline_class(**_lowercase	)
											snake_case_          =   pipe.to(_lowercase	)

											pipe.set_progress_bar_config(disable=_lowercase	)

											snake_case_          =   pipe(**self.get_dummy_inputs(_lowercase	)	)
											snake_case_          =   output.images[0]
											snake_case_          =   image[0, -3:, -3:, -1]

											assert image.shape == (20, 32, 32, 3)

											snake_case_          =   np.array(
											    [
											        0.00_03_92_16,
											        0.00_03_92_16,
											        0.00_03_92_16,
											        0.00_03_92_16,
											        0.00_03_92_16,
											        0.00_03_92_16,
											        0.00_03_92_16,
											        0.00_03_92_16,
											        0.00_03_92_16,
											    ]	)

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




				def    a							( self	):
											# NOTE: Larger batch sizes cause this test to timeout, only test on smaller batches
											self._test_inference_batch_consistent(batch_sizes=[1, 2]	)




				def    a							( self	):
											snake_case_          =   torch_device == 'cpu'
											snake_case_          =   True
											self._test_inference_batch_single_identical(
											    batch_size=2				,       test_max_difference=_lowercase				,       relax_max_difference=_lowercase				,       )




				def    a							( self	):
											snake_case_          =   self.get_dummy_components()
											snake_case_          =   self.pipeline_class(**_lowercase	)
											snake_case_          =   pipe.to(_lowercase	)
											pipe.set_progress_bar_config(disable=_lowercase	)

											snake_case_          =   1
											snake_case_          =   2

											snake_case_          =   self.get_dummy_inputs(_lowercase	)

											for key in inputs.keys():
																		if key in self.batch_params:
																									snake_case_          =   batch_size * [inputs[key]]

											snake_case_          =   pipe(**_lowercase				,       num_images_per_prompt=_lowercase	)[0]

											assert images.shape[0] == batch_size * num_images_per_prompt







@slow
@require_torch_gpu
class 			lowercase    (	unittest.TestCase      ):




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




				def    a							( self	):
											snake_case_          =   load_image(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/shap_e/corgi.png'	)
											snake_case_          =   load_numpy(
											    'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
											    '/shap_e/test_shap_e_img2img_out.npy'	)
											snake_case_          =   ShapEImgaImgPipeline.from_pretrained('openai/shap-e-img2img'	)
											snake_case_          =   pipe.to(_lowercase	)
											pipe.set_progress_bar_config(disable=_lowercase	)

											snake_case_          =   torch.Generator(device=_lowercase	).manual_seed(0	)

											snake_case_          =   pipe(
											    _lowercase				,       generator=_lowercase				,       guidance_scale=3.0				,       num_inference_steps=64				,       frame_size=64				,       output_type='np'				,       ).images[0]

											assert images.shape == (20, 64, 64, 3)

											assert_mean_pixel_difference(_lowercase				,       _lowercase	)







from math import sqrt





def  __lowerCamelCase     (			UpperCamelCase__				):







							'''simple docstring'''






							snake_case_          =   0
							for i in range(1       ,							int(sqrt(UpperCamelCase__				) + 1				)				):
														if n % i == 0 and i != sqrt(UpperCamelCase__				):
																					total += i + n // i
														elif i == sqrt(UpperCamelCase__				):
																					total += i
							return total - n





def  __lowerCamelCase     (			UpperCamelCase__ = 10000				):







							'''simple docstring'''






							snake_case_          =   sum(
							    i
							    for i in range(1       ,							UpperCamelCase__				)
							    if sum_of_divisors(sum_of_divisors(UpperCamelCase__				)				) == i and sum_of_divisors(UpperCamelCase__				) != i				)
							return total


if __name__ == "__main__":
					print(solution(int(str(input()).strip())))




