

import gc
import unittest

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

from diffusers import AutoencoderKL, DDIMScheduler, LDMTextToImagePipeline, UNetaDConditionModel
from diffusers.utils.testing_utils import (
    enable_full_determinism,
    load_numpy,
    nightly,
    require_torch_gpu,
    slow,
    torch_device,
)

from ..pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS
from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()







class 			lowercase    (	lowercase_     ,  unittest.TestCase      ):
				__SCREAMING_SNAKE_CASE :			Optional[Any]	      =      LDMTextToImagePipeline
				__SCREAMING_SNAKE_CASE :			str	      =      TEXT_TO_IMAGE_PARAMS - {
				    '''negative_prompt''',
				    '''negative_prompt_embeds''',
				    '''cross_attention_kwargs''',
				    '''prompt_embeds''',
				}
				__SCREAMING_SNAKE_CASE :			Dict	      =      PipelineTesterMixin.required_optional_params - {
				    '''num_images_per_prompt''',
				    '''callback''',
				    '''callback_steps''',
				}
				__SCREAMING_SNAKE_CASE :			Optional[int]	      =      TEXT_TO_IMAGE_BATCH_PARAMS
				__SCREAMING_SNAKE_CASE :			Optional[Any]	      =      False




				def    a							( self	):
											torch.manual_seed(0	)
											snake_case_          =   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				,       )
											snake_case_          =   DDIMScheduler(
											    beta_start=0.0_00_85				,       beta_end=0.0_12				,       beta_schedule='scaled_linear'				,       clip_sample=snake_case				,       set_alpha_to_one=snake_case				,       )
											torch.manual_seed(0	)
											snake_case_          =   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	)
											snake_case_          =   CLIPTextConfig(
											    bos_token_id=0				,       eos_token_id=2				,       hidden_size=32				,       intermediate_size=37				,       layer_norm_eps=1e-0_5				,       num_attention_heads=4				,       num_hidden_layers=5				,       pad_token_id=1				,       vocab_size=1000				,       )
											snake_case_          =   CLIPTextModel(snake_case	)
											snake_case_          =   CLIPTokenizer.from_pretrained('hf-internal-testing/tiny-random-clip'	)

											snake_case_          =   {
											    'unet': unet,
											    'scheduler': scheduler,
											    'vqvae': vae,
											    'bert': text_encoder,
											    'tokenizer': tokenizer,
											}
											return components




				def    a							( self				,       snake_case				,       snake_case=0	):
											if str(snake_case	).startswith('mps'	):
																		snake_case_          =   torch.manual_seed(snake_case	)
											else:
																		snake_case_          =   torch.Generator(device=snake_case	).manual_seed(snake_case	)
											snake_case_          =   {
											    'prompt': 'A painting of a squirrel eating a burger',
											    'generator': generator,
											    'num_inference_steps': 2,
											    'guidance_scale': 6.0,
											    'output_type': 'numpy',
											}
											return inputs




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

											snake_case_          =   self.get_dummy_components()
											snake_case_          =   LDMTextToImagePipeline(**snake_case	)
											pipe.to(snake_case	)
											pipe.set_progress_bar_config(disable=snake_case	)

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

											assert image.shape == (1, 16, 16, 3)
											snake_case_          =   np.array([0.61_01, 0.61_56, 0.56_22, 0.48_95, 0.66_61, 0.38_04, 0.57_48, 0.61_36, 0.50_14]	)

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







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




				def    a							( self	):
											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()




				def    a							( self				,       snake_case				,       snake_case=torch.floataa				,       snake_case=0	):
											snake_case_          =   torch.manual_seed(snake_case	)
											snake_case_          =   np.random.RandomState(snake_case	).standard_normal((1, 4, 32, 32)	)
											snake_case_          =   torch.from_numpy(snake_case	).to(device=snake_case				,       dtype=snake_case	)
											snake_case_          =   {
											    'prompt': 'A painting of a squirrel eating a burger',
											    'latents': latents,
											    'generator': generator,
											    'num_inference_steps': 3,
											    'guidance_scale': 6.0,
											    'output_type': 'numpy',
											}
											return inputs




				def    a							( self	):
											snake_case_          =   LDMTextToImagePipeline.from_pretrained('CompVis/ldm-text2im-large-256'	).to(snake_case	)
											pipe.set_progress_bar_config(disable=snake_case	)

											snake_case_          =   self.get_inputs(snake_case	)
											snake_case_          =   pipe(**snake_case	).images
											snake_case_          =   image[0, -3:, -3:, -1].flatten()

											assert image.shape == (1, 256, 256, 3)
											snake_case_          =   np.array([0.5_18_25, 0.5_28_50, 0.5_25_43, 0.5_42_58, 0.5_23_04, 0.5_25_69, 0.5_43_63, 0.5_52_76, 0.5_68_78]	)
											snake_case_          =   np.abs(expected_slice - image_slice	).max()
											assert max_diff < 1e-3







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




				def    a							( self	):
											super().tearDown()
											gc.collect()
											torch.cuda.empty_cache()




				def    a							( self				,       snake_case				,       snake_case=torch.floataa				,       snake_case=0	):
											snake_case_          =   torch.manual_seed(snake_case	)
											snake_case_          =   np.random.RandomState(snake_case	).standard_normal((1, 4, 32, 32)	)
											snake_case_          =   torch.from_numpy(snake_case	).to(device=snake_case				,       dtype=snake_case	)
											snake_case_          =   {
											    'prompt': 'A painting of a squirrel eating a burger',
											    'latents': latents,
											    'generator': generator,
											    'num_inference_steps': 50,
											    'guidance_scale': 6.0,
											    'output_type': 'numpy',
											}
											return inputs




				def    a							( self	):
											snake_case_          =   LDMTextToImagePipeline.from_pretrained('CompVis/ldm-text2im-large-256'	).to(snake_case	)
											pipe.set_progress_bar_config(disable=snake_case	)

											snake_case_          =   self.get_inputs(snake_case	)
											snake_case_          =   pipe(**snake_case	).images[0]

											snake_case_          =   load_numpy(
											    'https://huggingface.co/datasets/diffusers/test-arrays/resolve/main/ldm_text2img/ldm_large_256_ddim.npy'	)
											snake_case_          =   np.abs(expected_image - image	).max()
											assert max_diff < 1e-3







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




