




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 		__lowercase						(unittest.TestCase				):




      """simple docstring"""





      @property
      def       UpperCAmelCase ( self      )						->							List[Any]:
         torch.manual_seed(0      )
         snake_case :							Any           =			UNetaDModel(
             block_out_channels=(3_2, 6_4)							, layers_per_block=2							, sample_size=3_2							, in_channels=3							, out_channels=3							, down_block_types=("""DownBlock2D""", """AttnDownBlock2D""")							, up_block_types=("""AttnUpBlock2D""", """UpBlock2D""")							, )
         return model

      @property
      def       UpperCAmelCase ( self      )						->							Union[str, Any]:
         torch.manual_seed(0      )
         snake_case :							List[str]           =			VQModel(
             block_out_channels=[3_2, 6_4]							, in_channels=3							, out_channels=3							, down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]							, up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]							, latent_channels=3							, )
         return model

      @property
      def       UpperCAmelCase ( self      )						->							Union[str, Any]:
         torch.manual_seed(0      )
         snake_case :							Optional[int]           =			CLIPTextConfig(
             bos_token_id=0							, eos_token_id=2							, hidden_size=3_2							, intermediate_size=3_7							, layer_norm_eps=1e-0_5							, num_attention_heads=4							, num_hidden_layers=5							, pad_token_id=1							, vocab_size=1_0_0_0							, )
         return CLIPTextModel(_UpperCamelCase      )

      def       UpperCAmelCase ( self      )						->							List[str]:
         snake_case :							Tuple           =			self.dummy_uncond_unet
         snake_case :							Dict           =			DDIMScheduler()
         snake_case :							Any           =			self.dummy_vq_model

         snake_case :							List[str]           =			LDMPipeline(unet=_UpperCamelCase							, vqvae=_UpperCamelCase							, scheduler=_UpperCamelCase      )
         ldm.to(_UpperCamelCase      )
         ldm.set_progress_bar_config(disable=_UpperCamelCase      )

         snake_case :							List[Any]           =			torch.manual_seed(0      )
         snake_case :							int           =			ldm(generator=_UpperCamelCase							, num_inference_steps=2							, output_type="""numpy"""      ).images

         snake_case :							Optional[int]           =			torch.manual_seed(0      )
         snake_case :							int           =			ldm(generator=_UpperCamelCase							, num_inference_steps=2							, output_type="""numpy"""							, return_dict=_UpperCamelCase      )[0]

         snake_case :							Optional[Any]           =			image[0, -3:, -3:, -1]
         snake_case :							List[Any]           =			image_from_tuple[0, -3:, -3:, -1]

         assert image.shape == (1, 6_4, 6_4, 3)
         snake_case :							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]      )
         snake_case :							int           =			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 		__lowercase						(unittest.TestCase				):




      """simple docstring"""





      def       UpperCAmelCase ( self      )						->							List[Any]:
         snake_case :							Tuple           =			LDMPipeline.from_pretrained("""CompVis/ldm-celebahq-256"""      )
         ldm.to(_UpperCamelCase      )
         ldm.set_progress_bar_config(disable=_UpperCamelCase      )

         snake_case :							Any           =			torch.manual_seed(0      )
         snake_case :							Optional[int]           =			ldm(generator=_UpperCamelCase							, num_inference_steps=5							, output_type="""numpy"""      ).images

         snake_case :							int           =			image[0, -3:, -3:, -1]

         assert image.shape == (1, 2_5_6, 2_5_6, 3)
         snake_case :							Union[str, 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]      )
         snake_case :							List[str]           =			1e-2 if torch_device != """mps""" else 3e-2

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







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())))



