




import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch


if is_torch_available():
 import torch

 from transformers.activations import gelu_new, gelu_python, get_activation







@require_torch
class     A(		unittest.TestCase  ):



 '''simple docstring'''


 def 							a__					(							self   :    Optional[int]    )  ->      Optional[Any]:

       """simple docstring"""






       lowerCamelCase_							=       torch.tensor([-100, -1, -0.1, 0, 0.1, 1.0, 100]    )
       lowerCamelCase_							=       get_activation('gelu'    )
       self.assertTrue(torch.allclose(gelu_python(A_    )		,				torch_builtin(A_    )    )    )
       self.assertFalse(torch.allclose(gelu_python(A_    )		,				gelu_new(A_    )    )    )

 def 							a__					(							self   :    Union[str, Any]    )  ->      List[str]:

       """simple docstring"""






       lowerCamelCase_							=       torch.tensor([-100, -1, -0.1, 0, 0.1, 1.0, 100]    )
       lowerCamelCase_							=       get_activation('gelu'    )
       lowerCamelCase_							=       get_activation('gelu_10'    )

       lowerCamelCase_							=       torch_builtin(A_    )
       lowerCamelCase_							=       geluaa(A_    )

       lowerCamelCase_							=       torch.where(y_gelu_aa < 10.0		,				1		,				0    )

       self.assertTrue(torch.max(A_    ).item() == 10.0    )
       self.assertTrue(torch.allclose(y_gelu * clipped_mask		,				y_gelu_aa * clipped_mask    )    )

 def 							a__					(							self   :    Optional[Any]    )  ->      List[Any]:

       """simple docstring"""






       get_activation('gelu'    )
       get_activation('gelu_10'    )
       get_activation('gelu_fast'    )
       get_activation('gelu_new'    )
       get_activation('gelu_python'    )
       get_activation('gelu_pytorch_tanh'    )
       get_activation('linear'    )
       get_activation('mish'    )
       get_activation('quick_gelu'    )
       get_activation('relu'    )
       get_activation('sigmoid'    )
       get_activation('silu'    )
       get_activation('swish'    )
       get_activation('tanh'    )
       with self.assertRaises(A_    ):
             get_activation('bogus'    )
       with self.assertRaises(A_    ):
             get_activation(A_    )





 def 							a__					(							self   :    Tuple    )  ->      List[str]:

       """simple docstring"""






       lowerCamelCase_							=       get_activation('gelu'    )
       lowerCamelCase_							=       1
       lowerCamelCase_							=       get_activation('gelu'    )
       self.assertEqual(acta.a		,				1    )
       with self.assertRaises(A_    ):
             lowerCamelCase_							=       acta.a










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



