
import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image

from diffusers import (
    DDIMScheduler,
    KandinskyVaaControlnetImgaImgPipeline,
    KandinskyVaaPriorEmbaEmbPipeline,
    UNetaDConditionModel,
    VQModel,
)
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

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()





class       _lowerCAmelCase   (      __a   , unittest.TestCase			):
				_lowercase     						=KandinskyVaaControlnetImgaImgPipeline
				_lowercase     						=['''image_embeds''', '''negative_image_embeds''', '''image''', '''hint''']
				_lowercase     						=['''image_embeds''', '''negative_image_embeds''', '''image''', '''hint''']
				_lowercase     						=[
				    '''generator''',
				    '''height''',
				    '''width''',
				    '''strength''',
				    '''guidance_scale''',
				    '''num_inference_steps''',
				    '''return_dict''',
				    '''guidance_scale''',
				    '''num_images_per_prompt''',
				    '''output_type''',
				    '''return_dict''',
				]
				_lowercase     						=False




				@property
				def 	__a		(   self	)							-> int:
							return 32




				@property
				def 	__a		(   self	)							-> Optional[Any]:
							return 32




				@property
				def 	__a		(   self	)							-> List[str]:
							return self.time_input_dim




				@property
				def 	__a		(   self	)							-> Union[str, Any]:
							return self.time_input_dim * 4




				@property
				def 	__a		(   self	)							-> Optional[Any]:
							return 100




				@property
				def 	__a		(   self	)							-> Tuple:
							torch.manual_seed(0	)

							lowerCAmelCase_         =      {
							    "in_channels": 8,
							    # Out channels is double in channels because predicts mean and variance
							    "out_channels": 8,
							    "addition_embed_type": "image_hint",
							    "down_block_types": ("ResnetDownsampleBlock2D", "SimpleCrossAttnDownBlock2D"),
							    "up_block_types": ("SimpleCrossAttnUpBlock2D", "ResnetUpsampleBlock2D"),
							    "mid_block_type": "UNetMidBlock2DSimpleCrossAttn",
							    "block_out_channels": (self.block_out_channels_a, self.block_out_channels_a * 2),
							    "layers_per_block": 1,
							    "encoder_hid_dim": self.text_embedder_hidden_size,
							    "encoder_hid_dim_type": "image_proj",
							    "cross_attention_dim": self.cross_attention_dim,
							    "attention_head_dim": 4,
							    "resnet_time_scale_shift": "scale_shift",
							    "class_embed_type": None,
							}

							lowerCAmelCase_         =      UNetaDConditionModel(**_UpperCamelCase	)
							return model




				@property
				def 	__a		(   self	)							-> List[Any]:
							return {
							    "block_out_channels": [32, 32, 64, 64],
							    "down_block_types": [
							        "DownEncoderBlock2D",
							        "DownEncoderBlock2D",
							        "DownEncoderBlock2D",
							        "AttnDownEncoderBlock2D",
							    ],
							    "in_channels": 3,
							    "latent_channels": 4,
							    "layers_per_block": 1,
							    "norm_num_groups": 8,
							    "norm_type": "spatial",
							    "num_vq_embeddings": 12,
							    "out_channels": 3,
							    "up_block_types": ["AttnUpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D", "UpDecoderBlock2D"],
							    "vq_embed_dim": 4,
							}




				@property
				def 	__a		(   self	)							-> int:
							torch.manual_seed(0	)
							lowerCAmelCase_         =      VQModel(**self.dummy_movq_kwargs	)
							return model




				def 	__a		(   self	)							-> Any:
							lowerCAmelCase_         =      self.dummy_unet
							lowerCAmelCase_         =      self.dummy_movq

							lowerCAmelCase_         =      {
							    "num_train_timesteps": 1_000,
							    "beta_schedule": "linear",
							    "beta_start": 0.00085,
							    "beta_end": 0.012,
							    "clip_sample": False,
							    "set_alpha_to_one": False,
							    "steps_offset": 0,
							    "prediction_type": "epsilon",
							    "thresholding": False,
							}

							lowerCAmelCase_         =      DDIMScheduler(**_UpperCamelCase	)

							lowerCAmelCase_         =      {
							    "unet": unet,
							    "scheduler": scheduler,
							    "movq": movq,
							}

							return components




				def 	__a		(   self							,							_UpperCamelCase							,							_UpperCamelCase=0	)							-> List[str]:
							lowerCAmelCase_         =      floats_tensor((1, self.text_embedder_hidden_size)							,							rng=random.Random(_UpperCamelCase	)	).to(_UpperCamelCase	)
							lowerCAmelCase_         =      floats_tensor((1, self.text_embedder_hidden_size)							,							rng=random.Random(seed + 1	)	).to(
							    _UpperCamelCase	)
							# create init_image
							lowerCAmelCase_         =      floats_tensor((1, 3, 64, 64)							,							rng=random.Random(_UpperCamelCase	)	).to(_UpperCamelCase	)
							lowerCAmelCase_         =      image.cpu().permute(0							,							2							,							3							,							1	)[0]
							lowerCAmelCase_         =      Image.fromarray(np.uinta(_UpperCamelCase	)	).convert("RGB"	).resize((256, 256)	)
							# create hint
							lowerCAmelCase_         =      floats_tensor((1, 3, 64, 64)							,							rng=random.Random(_UpperCamelCase	)	).to(_UpperCamelCase	)

							if str(_UpperCamelCase	).startswith("mps"	):
										lowerCAmelCase_         =      torch.manual_seed(_UpperCamelCase	)
							else:
										lowerCAmelCase_         =      torch.Generator(device=_UpperCamelCase	).manual_seed(_UpperCamelCase	)
							lowerCAmelCase_         =      {
							    "image": init_image,
							    "image_embeds": image_embeds,
							    "negative_image_embeds": negative_image_embeds,
							    "hint": hint,
							    "generator": generator,
							    "height": 64,
							    "width": 64,
							    "num_inference_steps": 10,
							    "guidance_scale": 7.0,
							    "strength": 0.2,
							    "output_type": "np",
							}
							return inputs




				def 	__a		(   self	)							-> Tuple:
							lowerCAmelCase_         =      "cpu"

							lowerCAmelCase_         =      self.get_dummy_components()

							lowerCAmelCase_         =      self.pipeline_class(**_UpperCamelCase	)
							lowerCAmelCase_         =      pipe.to(_UpperCamelCase	)

							pipe.set_progress_bar_config(disable=_UpperCamelCase	)

							lowerCAmelCase_         =      pipe(**self.get_dummy_inputs(_UpperCamelCase	)	)
							lowerCAmelCase_         =      output.images

							lowerCAmelCase_         =      pipe(
							    **self.get_dummy_inputs(_UpperCamelCase	)							,							return_dict=_UpperCamelCase							,							)[0]

							lowerCAmelCase_         =      image[0, -3:, -3:, -1]
							lowerCAmelCase_         =      image_from_tuple[0, -3:, -3:, -1]

							assert image.shape == (1, 64, 64, 3)

							lowerCAmelCase_         =      np.array(
							    [0.54985034, 0.55509365, 0.52561504, 0.5570494, 0.5593818, 0.5263979, 0.50285643, 0.5069846, 0.51196736]	)
							assert (
							    np.abs(image_slice.flatten() - expected_slice	).max() < 1e-2
							), f""" expected_slice {expected_slice}, but got {image_slice.flatten()}"""
							assert (
							    np.abs(image_from_tuple_slice.flatten() - expected_slice	).max() < 1e-2
							), f""" expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}"""





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




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




				def 	__a		(   self	)							-> Any:
							lowerCAmelCase_         =      load_numpy(
							    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
							    "/kandinskyv22/kandinskyv22_controlnet_img2img_robotcat_fp16.npy"	)

							lowerCAmelCase_         =      load_image(
							    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" "/kandinsky/cat.png"	)
							lowerCAmelCase_         =      init_image.resize((512, 512)	)

							lowerCAmelCase_         =      load_image(
							    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
							    "/kandinskyv22/hint_image_cat.png"	)
							lowerCAmelCase_         =      torch.from_numpy(np.array(_UpperCamelCase	)	).float() / 255.0
							lowerCAmelCase_         =      hint.permute(2							,							0							,							1	).unsqueeze(0	)

							lowerCAmelCase_         =      "A robot, 4k photo"

							lowerCAmelCase_         =      KandinskyVaaPriorEmbaEmbPipeline.from_pretrained(
							    "kandinsky-community/kandinsky-2-2-prior"							,							torch_dtype=torch.floataa	)
							pipe_prior.to(_UpperCamelCase	)

							lowerCAmelCase_         =      KandinskyVaaControlnetImgaImgPipeline.from_pretrained(
							    "kandinsky-community/kandinsky-2-2-controlnet-depth"							,							torch_dtype=torch.floataa	)
							lowerCAmelCase_         =      pipeline.to(_UpperCamelCase	)

							pipeline.set_progress_bar_config(disable=_UpperCamelCase	)

							lowerCAmelCase_         =      torch.Generator(device="cpu"	).manual_seed(0	)

							lowerCAmelCase_      ,    lowerCAmelCase_         =      pipe_prior(
							    _UpperCamelCase							,							image=_UpperCamelCase							,							strength=0.85							,							generator=_UpperCamelCase							,							negative_prompt=""							,							).to_tuple()

							lowerCAmelCase_         =      pipeline(
							    image=_UpperCamelCase							,							image_embeds=_UpperCamelCase							,							negative_image_embeds=_UpperCamelCase							,							hint=_UpperCamelCase							,							generator=_UpperCamelCase							,							num_inference_steps=100							,							height=512							,							width=512							,							strength=0.5							,							output_type="np"							,							)

							lowerCAmelCase_         =      output.images[0]

							assert image.shape == (512, 512, 3)

							assert_mean_pixel_difference(_UpperCamelCase							,							_UpperCamelCase	)





from math import sqrt






def   lowerCamelCase__							(							__lowerCAmelCase    :    int							):




			"""simple docstring"""


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






def   lowerCamelCase__							(							__lowerCAmelCase    :    int = 10000							):




			"""simple docstring"""


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


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



