





"""simple docstring"""





import gc
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    StableDiffusionAttendAndExcitePipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_numpy, skip_mps, slow
from diffusers.utils.testing_utils import require_torch_gpu

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_IMAGE_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


SCREAMING_SNAKE_CASE__					=   False

@skip_mps
class 		lowercase					(					_UpperCAmelCase     ,  _UpperCAmelCase     ,  _UpperCAmelCase     ,  unittest.TestCase					):
      _SCREAMING_SNAKE_CASE					=      StableDiffusionAttendAndExcitePipeline
      _SCREAMING_SNAKE_CASE					=      False
      _SCREAMING_SNAKE_CASE					=      TEXT_TO_IMAGE_PARAMS
      _SCREAMING_SNAKE_CASE					=      TEXT_TO_IMAGE_BATCH_PARAMS.union({'token_indices'}					)
      _SCREAMING_SNAKE_CASE					=      TEXT_TO_IMAGE_IMAGE_PARAMS
      _SCREAMING_SNAKE_CASE					=      TEXT_TO_IMAGE_IMAGE_PARAMS





      @classmethod
      def     _snake_case			(       cls )		->     str:
            super().setUpClass()
            torch.use_deterministic_algorithms(lowercase )





      @classmethod
      def     _snake_case			(       cls )		->     List[Any]:
            super().tearDownClass()
            torch.use_deterministic_algorithms(lowercase )





      def     _snake_case			(       self )		->     str:
            torch.manual_seed(0 )
            lowerCAmelCase  						=       UNetaDConditionModel(
                block_out_channels=(32, 64)      ,						layers_per_block=1      ,						sample_size=32      ,						in_channels=4      ,						out_channels=4      ,						down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")      ,						up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")      ,						cross_attention_dim=32      ,						attention_head_dim=(2, 4)      ,						use_linear_projection=lowercase      ,						)
            lowerCAmelCase  						=       DDIMScheduler(
                beta_start=0.00_085      ,						beta_end=0.012      ,						beta_schedule="""scaled_linear"""      ,						clip_sample=lowercase      ,						set_alpha_to_one=lowercase      ,						)
            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      ,						sample_size=128      ,						)
            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=1_000      ,						hidden_act="""gelu"""      ,						projection_dim=512      ,						)
            lowerCAmelCase  						=       CLIPTextModel(lowercase )
            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      ,						lowercase      ,						lowercase=0 )		->     Optional[Any]:
            if str(lowercase ).startswith("""mps""" ):
                  lowerCAmelCase  						=       torch.manual_seed(lowercase )
            else:
                  lowerCAmelCase  						=       torch.Generator(device=lowercase ).manual_seed(lowercase )
            lowerCAmelCase  						=       lowerCAmelCase  						=       {
                """prompt""": """a cat and a frog""",
                """token_indices""": [2, 5],
                """generator""": generator,
                """num_inference_steps""": 1,
                """guidance_scale""": 6.0,
                """output_type""": """numpy""",
                """max_iter_to_alter""": 2,
                """thresholds""": {0: 0.7},
            }
            return inputs





      def     _snake_case			(       self )		->     Optional[int]:
            lowerCAmelCase  						=       """cpu"""

            lowerCAmelCase  						=       self.get_dummy_components()
            lowerCAmelCase  						=       self.pipeline_class(**lowercase )
            pipe.to(lowercase )
            pipe.set_progress_bar_config(disable=lowercase )

            lowerCAmelCase  						=       self.get_dummy_inputs(lowercase )
            lowerCAmelCase  						=       pipe(**lowercase ).images
            lowerCAmelCase  						=       image[0, -3:, -3:, -1]

            self.assertEqual(image.shape      ,						(1, 64, 64, 3) )
            lowerCAmelCase  						=       np.array(
                [0.63_905_364, 0.62_897_307, 0.48_599_017, 0.5_133_624, 0.5_550_048, 0.45_769_516, 0.50_326_973, 0.5_023_139, 0.45_384_496] )
            lowerCAmelCase  						=       np.abs(image_slice.flatten() - expected_slice ).max()
            self.assertLessEqual(lowercase      ,						1e-3 )





      def     _snake_case			(       self )		->     Union[str, Any]:
            super().test_cpu_offload_forward_pass(expected_max_diff=5e-4 )





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





      def     _snake_case			(       self )		->     Optional[int]:
            self._test_inference_batch_single_identical(batch_size=2      ,						expected_max_diff=7e-4 )





      def     _snake_case			(       self )		->     Optional[int]:
            super().test_dict_tuple_outputs_equivalent(expected_max_difference=3e-3 )





      def     _snake_case			(       self )		->     Optional[int]:
            super().test_pt_np_pil_outputs_equivalent(expected_max_diff=5e-4 )





      def     _snake_case			(       self )		->     int:
            super().test_save_load_local(expected_max_difference=5e-4 )





      def     _snake_case			(       self )		->     int:
            super().test_save_load_optional_components(expected_max_difference=4e-4 )







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





      @classmethod
      def     _snake_case			(       cls )		->     Dict:
            super().setUpClass()
            torch.use_deterministic_algorithms(lowercase )





      @classmethod
      def     _snake_case			(       cls )		->     Tuple:
            super().tearDownClass()
            torch.use_deterministic_algorithms(lowercase )





      def     _snake_case			(       self )		->     List[str]:
            super().tearDown()
            gc.collect()
            torch.cuda.empty_cache()





      def     _snake_case			(       self )		->     List[Any]:
            lowerCAmelCase  						=       torch.manual_seed(51 )

            lowerCAmelCase  						=       StableDiffusionAttendAndExcitePipeline.from_pretrained(
                """CompVis/stable-diffusion-v1-4"""      ,						safety_checker=lowercase      ,						torch_dtype=torch.floataa )
            pipe.to("""cuda""" )

            lowerCAmelCase  						=       """a painting of an elephant with glasses"""
            lowerCAmelCase  						=       [5, 7]

            lowerCAmelCase  						=       pipe(
                prompt=lowercase      ,						token_indices=lowercase      ,						guidance_scale=7.5      ,						generator=lowercase      ,						num_inference_steps=5      ,						max_iter_to_alter=5      ,						output_type="""numpy"""      ,						).images[0]

            lowerCAmelCase  						=       load_numpy(
                """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/attend-and-excite/elephant_glasses.npy""" )
            assert np.abs((expected_image - image).max() ) < 5e-1









"""simple docstring"""





from math import sqrt




def   _A  (  UpperCamelCase_     :       int)	->						int:
   '''simple docstring'''


   __lowercase								=						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   _A  (  UpperCamelCase_     :       int = 10000)	->						int:
   '''simple docstring'''


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




