
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       _lowerCAmelCase   (      unittest.TestCase			):




				def 	__a		(   self							,							_UpperCamelCase							,							_UpperCamelCase							,							_UpperCamelCase	)							-> Dict:
							self.assertEqual(len(_UpperCamelCase	)							,							len(_UpperCamelCase	)	)
							for a, b in zip(_UpperCamelCase							,							_UpperCamelCase	):
										self.assertAlmostEqual(_UpperCamelCase							,							_UpperCamelCase							,							delta=_UpperCamelCase	)




				def 	__a		(   self	)							-> List[str]:
							lowerCAmelCase_         =      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(_UpperCamelCase	):
										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	)							-> Union[str, Any]:
							lowerCAmelCase_         =      None
							ops.enable_eager_execution_internal()
							lowerCAmelCase_         =      tf.config.list_physical_devices("CPU"	)
							if len(_UpperCamelCase	) == 1:
										tf.config.set_logical_device_configuration(
										    physical_devices[0]							,							[tf.config.LogicalDeviceConfiguration(), tf.config.LogicalDeviceConfiguration()]	)
							lowerCAmelCase_         =      tf.config.list_logical_devices(device_type="CPU"	)
							lowerCAmelCase_         =      tf.distribute.MirroredStrategy(devices=devices[:2]	)

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

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

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

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

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

							def _check_local_values(_UpperCamelCase							,							_UpperCamelCase	):
										lowerCAmelCase_         =      strategy.experimental_local_results(accumulator._gradients[0]	)
										self.assertListAlmostEqual(values[0].value()							,							_UpperCamelCase							,							tol=1e-2	)
										self.assertListAlmostEqual(values[1].value()							,							_UpperCamelCase							,							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__							(							__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())))



