





'''simple docstring'''




import random
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    UNetaDConditionModel,
    VideoToVideoSDPipeline,
)
from diffusers.utils import floats_tensor, is_xformers_available, skip_mps
from diffusers.utils.testing_utils import enable_full_determinism, slow, torch_device

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


enable_full_determinism()




@skip_mps
class      UpperCamelCase__					(					lowercase_						,					unittest.TestCase			):




					"""simple docstring"""
					SCREAMING_SNAKE_CASE__				=	VideoToVideoSDPipeline
					SCREAMING_SNAKE_CASE__				=	TEXT_GUIDED_IMAGE_VARIATION_PARAMS.union({'''video'''}			) - {'''image''', '''width''', '''height'''}
					SCREAMING_SNAKE_CASE__				=	TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({'''video'''}			) - {'''image'''}
					SCREAMING_SNAKE_CASE__				=	PipelineTesterMixin.required_optional_params - {'''latents'''}
					SCREAMING_SNAKE_CASE__				=	False

					# No `output_type`.
					SCREAMING_SNAKE_CASE__				=	frozenset(
					    [
					        '''num_inference_steps''',
					        '''generator''',
					        '''latents''',
					        '''return_dict''',
					        '''callback''',
					        '''callback_steps''',
					    ]			)


					def lowerCamelCase_			(						self				:			Dict						):

							'''simple docstring'''



							torch.manual_seed(0						)
							SCREAMING_SNAKE_CASE :				Optional[Any]		=			UNetaDConditionModel(
							    block_out_channels=(32, 64, 64, 64)      ,						layers_per_block=2      ,						sample_size=32      ,						in_channels=4      ,						out_channels=4      ,						down_block_types=("""CrossAttnDownBlock3D""", """CrossAttnDownBlock3D""", """CrossAttnDownBlock3D""", """DownBlock3D""")      ,						up_block_types=("""UpBlock3D""", """CrossAttnUpBlock3D""", """CrossAttnUpBlock3D""", """CrossAttnUpBlock3D""")      ,						cross_attention_dim=32      ,						attention_head_dim=4      ,						)
							SCREAMING_SNAKE_CASE :				str		=			DDIMScheduler(
							    beta_start=0.00_085      ,						beta_end=0.012      ,						beta_schedule="""scaled_linear"""      ,						clip_sample=lowerCamelCase_      ,						set_alpha_to_one=lowerCamelCase_      ,						)
							torch.manual_seed(0						)
							SCREAMING_SNAKE_CASE :				Any		=			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=1_28      ,						)
							torch.manual_seed(0						)
							SCREAMING_SNAKE_CASE :				Optional[int]		=			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=10_00      ,						hidden_act="""gelu"""      ,						projection_dim=5_12      ,						)
							SCREAMING_SNAKE_CASE :				Dict		=			CLIPTextModel(lowerCamelCase_						)
							SCREAMING_SNAKE_CASE :				Dict		=			CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""						)

							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			{
							    """unet""": unet,
							    """scheduler""": scheduler,
							    """vae""": vae,
							    """text_encoder""": text_encoder,
							    """tokenizer""": tokenizer,
							}
							return components


					def lowerCamelCase_			(						self				:			List[Any]      ,						lowerCamelCase_				:			List[Any]      ,						lowerCamelCase_				:			List[Any]=0						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				List[Any]		=			floats_tensor((1, 3, 3, 32, 32)      ,						rng=random.Random(lowerCamelCase_						)						).to(lowerCamelCase_						)

							if str(lowerCamelCase_						).startswith("""mps"""						):
									SCREAMING_SNAKE_CASE :				Any		=			torch.manual_seed(lowerCamelCase_						)
							else:
									SCREAMING_SNAKE_CASE :				Tuple		=			torch.Generator(device=lowerCamelCase_						).manual_seed(lowerCamelCase_						)
							SCREAMING_SNAKE_CASE :				Optional[Any]		=			{
							    """prompt""": """A painting of a squirrel eating a burger""",
							    """video""": video,
							    """generator""": generator,
							    """num_inference_steps""": 2,
							    """guidance_scale""": 6.0,
							    """output_type""": """pt""",
							}
							return inputs


					def lowerCamelCase_			(						self				:			str						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				Dict		=			"""cpu"""  # ensure determinism for the device-dependent torch.Generator
							SCREAMING_SNAKE_CASE :				Tuple		=			self.get_dummy_components()
							SCREAMING_SNAKE_CASE :				Optional[int]		=			VideoToVideoSDPipeline(**lowerCamelCase_						)
							SCREAMING_SNAKE_CASE :				str		=			sd_pipe.to(lowerCamelCase_						)
							sd_pipe.set_progress_bar_config(disable=lowerCamelCase_						)

							SCREAMING_SNAKE_CASE :				Dict		=			self.get_dummy_inputs(lowerCamelCase_						)
							SCREAMING_SNAKE_CASE :				List[Any]		=			"""np"""
							SCREAMING_SNAKE_CASE :				Optional[int]		=			sd_pipe(**lowerCamelCase_						).frames
							SCREAMING_SNAKE_CASE :				List[str]		=			frames[0][-3:, -3:, -1]

							assert frames[0].shape == (32, 32, 3)
							SCREAMING_SNAKE_CASE :				List[str]		=			np.array([1_06, 1_17, 1_13, 1_74, 1_37, 1_12, 1_48, 1_51, 1_31]						)

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


					@unittest.skipIf(
					    torch_device != """cuda""" or not is_xformers_available()      ,						reason="""XFormers attention is only available with CUDA and `xformers` installed"""      ,						)
					def lowerCamelCase_			(						self				:			str						):

							'''simple docstring'''



							self._test_xformers_attention_forwardGenerator_pass(test_mean_pixel_difference=lowerCamelCase_      ,						expected_max_diff=5e-3						)


					@unittest.skip(reason="""Batching needs to be properly figured out first for this pipeline."""						)
					def lowerCamelCase_			(						self				:			List[Any]						):

							'''simple docstring'''



							pass


					@unittest.skip(reason="""Batching needs to be properly figured out first for this pipeline."""						)
					def lowerCamelCase_			(						self				:			List[str]						):

							'''simple docstring'''



							pass


					@unittest.skip(reason="""`num_images_per_prompt` argument is not supported for this pipeline."""						)
					def lowerCamelCase_			(						self				:			Union[str, Any]						):

							'''simple docstring'''



							pass



					def lowerCamelCase_			(						self				:			List[Any]						):

							'''simple docstring'''



							return super().test_progress_bar()







@slow
@skip_mps
class      UpperCamelCase__					(					unittest.TestCase			):




					"""simple docstring"""


					def lowerCamelCase_			(						self				:			Any						):

							'''simple docstring'''



							SCREAMING_SNAKE_CASE :				Dict		=			VideoToVideoSDPipeline.from_pretrained("""cerspense/zeroscope_v2_XL"""      ,						torch_dtype=torch.floataa						)
							pipe.enable_model_cpu_offload()

							# 10 frames
							SCREAMING_SNAKE_CASE :				Any		=			torch.Generator(device="""cpu"""						).manual_seed(0						)
							SCREAMING_SNAKE_CASE :				Optional[int]		=			torch.randn((1, 10, 3, 10_24, 5_76)      ,						generator=lowerCamelCase_						)
							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			video.to("""cuda"""						)

							SCREAMING_SNAKE_CASE :				Tuple		=			"""Spiderman is surfing"""

							SCREAMING_SNAKE_CASE :				List[Any]		=			pipe(lowerCamelCase_      ,						video=lowerCamelCase_      ,						generator=lowerCamelCase_      ,						num_inference_steps=3      ,						output_type="""pt"""						).frames

							SCREAMING_SNAKE_CASE :				Union[str, Any]		=			np.array([-1.0_458_984, -1.1_279_297, -0.9_663_086, -0.91_503_906, -0.75_097_656]						)
							assert np.abs(video_frames.cpu().numpy()[0, 0, 0, 0, -5:] - expected_array						).sum() < 1e-2










'''simple docstring'''




from math import sqrt



def 		__A		(  lowerCamelCase_	):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE :				str		=			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 		__A		(  lowerCamelCase_ = 1_00_00	):


		"""simple docstring"""



		SCREAMING_SNAKE_CASE :				str		=			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())))



