import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_tf


if is_tf_available():
					import tensorflow as tf
					from tensorflow.python.eager import context
					from tensorflow.python.framework import ops

					from transformers import GradientAccumulator, create_optimizer







@require_tf
class 			lowercase    (	unittest.TestCase      ):




				def    a							( self				,       snake_case				,       snake_case				,       snake_case	):
											self.assertEqual(len(snake_case	)				,       len(snake_case	)	)
											for a, b in zip(snake_case				,       snake_case	):
																		self.assertAlmostEqual(snake_case				,       snake_case				,       delta=snake_case	)




				def    a							( self	):
											snake_case_          =   GradientAccumulator()
											accumulator([tf.constant([1.0, 2.0]	)]	)
											accumulator([tf.constant([-2.0, 1.0]	)]	)
											accumulator([tf.constant([-1.0, 2.0]	)]	)
											with self.assertRaises(snake_case	):
																		accumulator([tf.constant([1.0, 1.0]	), tf.constant([2.0, 2.0]	)]	)
											self.assertEqual(accumulator.step				,       3	)
											self.assertEqual(len(accumulator.gradients	)				,       1	)
											self.assertListAlmostEqual(accumulator.gradients[0].numpy().tolist()				,       [-2.0, 5.0]				,       tol=1e-2	)
											accumulator.reset()
											self.assertEqual(accumulator.step				,       0	)
											self.assertListAlmostEqual(accumulator.gradients[0].numpy().tolist()				,       [0.0, 0.0]				,       tol=1e-2	)




				def    a							( self	):
											snake_case_          =   None
											ops.enable_eager_execution_internal()
											snake_case_          =   tf.config.list_physical_devices('CPU'	)
											if len(snake_case	) == 1:
																		tf.config.set_logical_device_configuration(
																		    physical_devices[0]				,       [tf.config.LogicalDeviceConfiguration(), tf.config.LogicalDeviceConfiguration()]	)
											snake_case_          =   tf.config.list_logical_devices(device_type='CPU'	)
											snake_case_          =   tf.distribute.MirroredStrategy(devices=devices[:2]	)

											with strategy.scope():
																		snake_case_          =   GradientAccumulator()
																		snake_case_          =   tf.Variable([4.0, 3.0]	)
																		snake_case_    ,   snake_case_          =   create_optimizer(5e-5				,       10				,       5	)
																		snake_case_          =   tf.Variable([0.0, 0.0]				,       trainable=snake_case	)

											def accumulate_on_replica(snake_case	):
																		accumulator([gradient]	)

											def apply_on_replica():
																		optimizer.apply_gradients(list(zip(accumulator.gradients				,       [variable]	)	)	)

											@tf.function
											def accumulate(snake_case				,       snake_case	):
																		with strategy.scope():
																									snake_case_          =   strategy.experimental_local_results(snake_case	)
																									local_variables[0].assign(snake_case	)
																									local_variables[1].assign(snake_case	)
																									strategy.run(snake_case				,       args=(gradient_placeholder,)	)

											@tf.function
											def apply_grad():
																		with strategy.scope():
																									strategy.run(snake_case	)

											def _check_local_values(snake_case				,       snake_case	):
																		snake_case_          =   strategy.experimental_local_results(accumulator._gradients[0]	)
																		self.assertListAlmostEqual(values[0].value()				,       snake_case				,       tol=1e-2	)
																		self.assertListAlmostEqual(values[1].value()				,       snake_case				,       tol=1e-2	)

											accumulate([1.0, 2.0]				,       [-1.0, 1.0]	)
											accumulate([3.0, -1.0]				,       [-1.0, -1.0]	)
											accumulate([-2.0, 2.0]				,       [3.0, -2.0]	)
											self.assertEqual(accumulator.step				,       3	)
											_check_local_values([2.0, 3.0]				,       [1.0, -2.0]	)
											apply_grad()
											self.assertListAlmostEqual(variable.value()				,       [4.0, 3.0]				,       tol=1e-2	)
											accumulator.reset()
											self.assertEqual(accumulator.step				,       0	)
											_check_local_values([0.0, 0.0]				,       [0.0, 0.0]	)







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




