


import gc
import random
import unittest

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

from diffusers import AutoencoderKL, CycleDiffusionPipeline, DDIMScheduler, UNetaDConditionModel
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()

class       __A     (						__SCREAMING_SNAKE_CASE    ,					__SCREAMING_SNAKE_CASE    ,					unittest.TestCase    ):
				__A      =				CycleDiffusionPipeline
				__A      =				TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
				    """negative_prompt""",
				    """height""",
				    """width""",
				    """negative_prompt_embeds""",
				}
				__A      =				PipelineTesterMixin.required_optional_params - {"""latents"""}
				__A      =				TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"""source_prompt"""}    )
				__A      =				IMAGE_TO_IMAGE_IMAGE_PARAMS
				__A      =				IMAGE_TO_IMAGE_IMAGE_PARAMS


				def _snake_case       (		self							):
								torch.manual_seed(0							)
								lowerCamelCase	 =UNetaDConditionModel(
								    block_out_channels=(32, 64)   , layers_per_block=2   , sample_size=32   , in_channels=4   , out_channels=4   , down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")   , up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")   , cross_attention_dim=32   , )
								lowerCamelCase	 =DDIMScheduler(
								    beta_start=0.0_0_0_8_5   , beta_end=0.0_1_2   , beta_schedule="""scaled_linear"""   , num_train_timesteps=1000   , clip_sample=__snake_case   , set_alpha_to_one=__snake_case   , )
								torch.manual_seed(0							)
								lowerCamelCase	 =AutoencoderKL(
								    block_out_channels=[32, 64]   , in_channels=3   , out_channels=3   , down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]   , up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]   , latent_channels=4   , )
								torch.manual_seed(0							)
								lowerCamelCase	 =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=1000   , )
								lowerCamelCase	 =CLIPTextModel(__snake_case							)
								lowerCamelCase	 =CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""							)

								lowerCamelCase	 ={
								    '''unet''': unet,
								    '''scheduler''': scheduler,
								    '''vae''': vae,
								    '''text_encoder''': text_encoder,
								    '''tokenizer''': tokenizer,
								    '''safety_checker''': None,
								    '''feature_extractor''': None,
								}
								return components


				def _snake_case       (		self   , UpperCAmelCase_   , UpperCAmelCase_=0							):
								lowerCamelCase	 =floats_tensor((1, 3, 32, 32)   , rng=random.Random(__snake_case							)							).to(__snake_case							)
								lowerCamelCase	 =image / 2 + 0.5
								if str(__snake_case							).startswith("""mps"""							):
												lowerCamelCase	 =torch.manual_seed(__snake_case							)
								else:
												lowerCamelCase	 =torch.Generator(device=__snake_case							).manual_seed(__snake_case							)
								lowerCamelCase	 ={
								    '''prompt''': '''An astronaut riding an elephant''',
								    '''source_prompt''': '''An astronaut riding a horse''',
								    '''image''': image,
								    '''generator''': generator,
								    '''num_inference_steps''': 2,
								    '''eta''': 0.1,
								    '''strength''': 0.8,
								    '''guidance_scale''': 3,
								    '''source_guidance_scale''': 1,
								    '''output_type''': '''numpy''',
								}
								return inputs


				def _snake_case       (		self							):
								lowerCamelCase	 ='''cpu'''  # ensure determinism for the device-dependent torch.Generator

								lowerCamelCase	 =self.get_dummy_components()
								lowerCamelCase	 =CycleDiffusionPipeline(**__snake_case							)
								lowerCamelCase	 =pipe.to(__snake_case							)
								pipe.set_progress_bar_config(disable=__snake_case							)

								lowerCamelCase	 =self.get_dummy_inputs(__snake_case							)
								lowerCamelCase	 =pipe(**__snake_case							)
								lowerCamelCase	 =output.images

								lowerCamelCase	 =images[0, -3:, -3:, -1]

								assert images.shape == (1, 32, 32, 3)
								lowerCamelCase	 =np.array([0.4_4_5_9, 0.4_9_4_3, 0.4_5_4_4, 0.6_6_4_3, 0.5_4_7_4, 0.4_3_2_7, 0.5_7_0_1, 0.5_9_5_9, 0.5_1_7_9]							)

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


				@unittest.skipIf(torch_device != """cuda"""   , """This test requires a GPU"""							)
				def _snake_case       (		self							):
								lowerCamelCase	 =self.get_dummy_components()
								for name, module in components.items():
												if hasattr(__snake_case   , """half"""							):
																lowerCamelCase	 =module.half()
								lowerCamelCase	 =CycleDiffusionPipeline(**__snake_case							)
								lowerCamelCase	 =pipe.to(__snake_case							)
								pipe.set_progress_bar_config(disable=__snake_case							)

								lowerCamelCase	 =self.get_dummy_inputs(__snake_case							)
								lowerCamelCase	 =pipe(**__snake_case							)
								lowerCamelCase	 =output.images

								lowerCamelCase	 =images[0, -3:, -3:, -1]

								assert images.shape == (1, 32, 32, 3)
								lowerCamelCase	 =np.array([0.3_5_0_6, 0.4_5_4_3, 0.4_4_6, 0.4_5_7_5, 0.5_1_9_5, 0.4_1_5_5, 0.5_2_7_3, 0.5_1_8, 0.4_1_1_6]							)

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


				@skip_mps
				def _snake_case       (		self							):
								return super().test_save_load_local()


				@unittest.skip("""non-deterministic pipeline"""							)
				def _snake_case       (		self							):
								return super().test_inference_batch_single_identical()


				@skip_mps
				def _snake_case       (		self							):
								return super().test_dict_tuple_outputs_equivalent()


				@skip_mps
				def _snake_case       (		self							):
								return super().test_save_load_optional_components()


				@skip_mps
				def _snake_case       (		self							):
								return super().test_attention_slicing_forward_pass()




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


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


				def _snake_case       (		self							):
								lowerCamelCase	 =load_image(
								    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
								    """/cycle-diffusion/black_colored_car.png"""							)
								lowerCamelCase	 =load_numpy(
								    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/cycle-diffusion/blue_colored_car_fp16.npy"""							)
								lowerCamelCase	 =init_image.resize((512, 512)							)

								lowerCamelCase	 ='''CompVis/stable-diffusion-v1-4'''
								lowerCamelCase	 =DDIMScheduler.from_pretrained(__snake_case   , subfolder="""scheduler"""							)
								lowerCamelCase	 =CycleDiffusionPipeline.from_pretrained(
								    __snake_case   , scheduler=__snake_case   , safety_checker=__snake_case   , torch_dtype=torch.floataa   , revision="""fp16"""							)

								pipe.to(__snake_case							)
								pipe.set_progress_bar_config(disable=__snake_case							)
								pipe.enable_attention_slicing()

								lowerCamelCase	 ='''A black colored car'''
								lowerCamelCase	 ='''A blue colored car'''

								lowerCamelCase	 =torch.manual_seed(0							)
								lowerCamelCase	 =pipe(
								    prompt=__snake_case   , source_prompt=__snake_case   , image=__snake_case   , num_inference_steps=100   , eta=0.1   , strength=0.8_5   , guidance_scale=3   , source_guidance_scale=1   , generator=__snake_case   , output_type="""np"""   , )
								lowerCamelCase	 =output.images

								# the values aren't exactly equal, but the images look the same visually
								assert np.abs(image - expected_image							).max() < 5E-1


				def _snake_case       (		self							):
								lowerCamelCase	 =load_image(
								    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
								    """/cycle-diffusion/black_colored_car.png"""							)
								lowerCamelCase	 =load_numpy(
								    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/cycle-diffusion/blue_colored_car.npy"""							)
								lowerCamelCase	 =init_image.resize((512, 512)							)

								lowerCamelCase	 ='''CompVis/stable-diffusion-v1-4'''
								lowerCamelCase	 =DDIMScheduler.from_pretrained(__snake_case   , subfolder="""scheduler"""							)
								lowerCamelCase	 =CycleDiffusionPipeline.from_pretrained(__snake_case   , scheduler=__snake_case   , safety_checker=__snake_case							)

								pipe.to(__snake_case							)
								pipe.set_progress_bar_config(disable=__snake_case							)
								pipe.enable_attention_slicing()

								lowerCamelCase	 ='''A black colored car'''
								lowerCamelCase	 ='''A blue colored car'''

								lowerCamelCase	 =torch.manual_seed(0							)
								lowerCamelCase	 =pipe(
								    prompt=__snake_case   , source_prompt=__snake_case   , image=__snake_case   , num_inference_steps=100   , eta=0.1   , strength=0.8_5   , guidance_scale=3   , source_guidance_scale=1   , generator=__snake_case   , output_type="""np"""   , )
								lowerCamelCase	 =output.images

								assert np.abs(image - expected_image							).max() < 2E-2












from math import sqrt





def      _lowercase					(						_UpperCAmelCase				)						->  int:
				lowerCamelCase	 =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      _lowercase					(						_UpperCAmelCase = 1_00_00				)						->  int:
				lowerCamelCase	 =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())))





