
from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    center_crop,
    get_resize_output_image_size,
    normalize,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_DEFAULT_MEAN,
    IMAGENET_DEFAULT_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    is_batched,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging


_A  =	logging.get_logger(__name__)





class       _lowerCAmelCase   (      __a			):
				_lowercase     						=['''pixel_values''']




				def __init__(   self							,							_UpperCamelCase = True							,							_UpperCamelCase = None							,							_UpperCamelCase = PILImageResampling.BICUBIC							,							_UpperCamelCase = True							,							_UpperCamelCase = True							,							_UpperCamelCase = 1 / 255							,							_UpperCamelCase = None							,							_UpperCamelCase = True							,							_UpperCamelCase = None							,							_UpperCamelCase = None							,							**_UpperCamelCase							,							)							-> None:
							super().__init__(**_UpperCamelCase	)
							lowerCAmelCase_         =      size if size is not None else {"height": 224, "width": 224}
							lowerCAmelCase_         =      get_size_dict(_UpperCamelCase	)
							lowerCAmelCase_         =      crop_size if crop_size is not None else {"height": 224, "width": 224}
							lowerCAmelCase_         =      get_size_dict(_UpperCamelCase							,							default_to_square=_UpperCamelCase							,							param_name="crop_size"	)

							lowerCAmelCase_         =      do_resize
							lowerCAmelCase_         =      do_rescale
							lowerCAmelCase_         =      do_normalize
							lowerCAmelCase_         =      do_center_crop
							lowerCAmelCase_         =      crop_size
							lowerCAmelCase_         =      size
							lowerCAmelCase_         =      resample
							lowerCAmelCase_         =      rescale_factor
							lowerCAmelCase_         =      image_mean if image_mean is not None else IMAGENET_DEFAULT_MEAN
							lowerCAmelCase_         =      image_std if image_std is not None else IMAGENET_DEFAULT_STD




				def 	__a		(   self							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase = PILImageResampling.BILINEAR							,							_UpperCamelCase = None							,							**_UpperCamelCase							,							)							-> np.ndarray:
							lowerCAmelCase_         =      get_size_dict(_UpperCamelCase	)

							if "shortest_edge" in size:
										lowerCAmelCase_         =      get_resize_output_image_size(_UpperCamelCase							,							size=size["shortest_edge"]							,							default_to_square=_UpperCamelCase	)
										# size = get_resize_output_image_size(image, size["shortest_edge"], size["longest_edge"])
							elif "height" in size and "width" in size:
										lowerCAmelCase_         =      (size["height"], size["width"])
							else:
										raise ValueError(f"""Size must contain 'height' and 'width' keys or 'shortest_edge' key. Got {size.keys()}"""	)
							return resize(_UpperCamelCase							,							size=_UpperCamelCase							,							resample=_UpperCamelCase							,							data_format=_UpperCamelCase							,							**_UpperCamelCase	)




				def 	__a		(   self							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase = None							,							**_UpperCamelCase							,							)							-> np.ndarray:
							lowerCAmelCase_         =      get_size_dict(_UpperCamelCase	)
							if "height" not in size or "width" not in size:
										raise ValueError(f"""The `size` parameter must contain the keys (height, width). Got {size.keys()}"""	)
							return center_crop(_UpperCamelCase							,							size=(size["height"], size["width"])							,							data_format=_UpperCamelCase							,							**_UpperCamelCase	)




				def 	__a		(   self							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase = None							,							**_UpperCamelCase	)							-> np.ndarray:
							return rescale(_UpperCamelCase							,							scale=_UpperCamelCase							,							data_format=_UpperCamelCase							,							**_UpperCamelCase	)




				def 	__a		(   self							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase = None							,							**_UpperCamelCase							,							)							-> np.ndarray:
							return normalize(_UpperCamelCase							,							mean=_UpperCamelCase							,							std=_UpperCamelCase							,							data_format=_UpperCamelCase							,							**_UpperCamelCase	)




				def 	__a		(   self							,							_UpperCamelCase							,							_UpperCamelCase = None							,							_UpperCamelCase = None							,							_UpperCamelCase = None							,							_UpperCamelCase = None							,							_UpperCamelCase = None							,							_UpperCamelCase = None							,							_UpperCamelCase = None							,							_UpperCamelCase = None							,							_UpperCamelCase = None							,							_UpperCamelCase = None							,							_UpperCamelCase = None							,							_UpperCamelCase = ChannelDimension.FIRST							,							**_UpperCamelCase							,							)							-> BatchFeature:
							lowerCAmelCase_         =      do_resize if do_resize is not None else self.do_resize
							lowerCAmelCase_         =      do_rescale if do_rescale is not None else self.do_rescale
							lowerCAmelCase_         =      do_normalize if do_normalize is not None else self.do_normalize
							lowerCAmelCase_         =      do_center_crop if do_center_crop is not None else self.do_center_crop
							lowerCAmelCase_         =      crop_size if crop_size is not None else self.crop_size
							lowerCAmelCase_         =      get_size_dict(_UpperCamelCase							,							param_name="crop_size"							,							default_to_square=_UpperCamelCase	)
							lowerCAmelCase_         =      resample if resample is not None else self.resample
							lowerCAmelCase_         =      rescale_factor if rescale_factor is not None else self.rescale_factor
							lowerCAmelCase_         =      image_mean if image_mean is not None else self.image_mean
							lowerCAmelCase_         =      image_std if image_std is not None else self.image_std

							lowerCAmelCase_         =      size if size is not None else self.size
							lowerCAmelCase_         =      get_size_dict(_UpperCamelCase	)

							if not is_batched(_UpperCamelCase	):
										lowerCAmelCase_         =      [images]

							if not valid_images(_UpperCamelCase	):
										raise ValueError(
										    "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
										    "torch.Tensor, tf.Tensor or jax.ndarray."	)

							if do_resize and size is None:
										raise ValueError("Size must be specified if do_resize is True."	)

							if do_center_crop and crop_size is None:
										raise ValueError("Crop size must be specified if do_center_crop is True."	)

							if do_rescale and rescale_factor is None:
										raise ValueError("Rescale factor must be specified if do_rescale is True."	)

							# All transformations expect numpy arrays.
							lowerCAmelCase_         =      [to_numpy_array(_UpperCamelCase	) for image in images]

							if do_resize:
										lowerCAmelCase_         =      [self.resize(image=_UpperCamelCase							,							size=_UpperCamelCase							,							resample=_UpperCamelCase	) for image in images]

							if do_center_crop:
										lowerCAmelCase_         =      [self.center_crop(image=_UpperCamelCase							,							size=_UpperCamelCase	) for image in images]

							if do_rescale:
										lowerCAmelCase_         =      [self.rescale(image=_UpperCamelCase							,							scale=_UpperCamelCase	) for image in images]

							if do_normalize:
										lowerCAmelCase_         =      [self.normalize(image=_UpperCamelCase							,							mean=_UpperCamelCase							,							std=_UpperCamelCase	) for image in images]

							lowerCAmelCase_         =      [to_channel_dimension_format(_UpperCamelCase							,							_UpperCamelCase	) for image in images]

							lowerCAmelCase_         =      {"pixel_values": images}
							return BatchFeature(data=_UpperCamelCase							,							tensor_type=_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())))



