



'''simple docstring'''



from math import sqrt
def 					UpperCAmelCase   (						A  :				int				):
							SCREAMING_SNAKE_CASE					:      Optional[int]     					=			0
							for i in range(1					,		int(sqrt(A				) + 1				)				):
														if n % i == 0 and i != sqrt(A				):
																					total += i + n // i
														elif i == sqrt(A				):
																					total += i
							return total - n
def 					UpperCAmelCase   (						A  :				int = 10000				):
							SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			sum(
							    i
							    for i in range(1					,		A				)
							    if sum_of_divisors(sum_of_divisors(A				)				) == i and sum_of_divisors(A				) != i				)
							return total


if __name__ == "__main__":
							print(solution(int(str(input()).strip())))









'''simple docstring'''



import darl  # noqa
import gym
import tqdm
from diffusers.experimental import ValueGuidedRLPipeline


lowerCAmelCase_     :       int								=						{
    'n_samples': 64,
    'horizon': 32,
    'num_inference_steps': 20,
    'n_guide_steps': 2,  # can set to 0 for faster sampling, does not use value network
    'scale_grad_by_std': True,
    'scale': 0.1,
    'eta': 0.0,
    't_grad_cutoff': 2,
    'device': 'cpu',
}


if __name__ == "__main__":
							lowerCAmelCase_     :       int								=						'hopper-medium-v2'
							lowerCAmelCase_     :       str								=						gym.make(env_name)

							lowerCAmelCase_     :       Union[str, Any]								=						ValueGuidedRLPipeline.from_pretrained(
							    'bglick13/hopper-medium-v2-value-function-hor32',
							    env=env,
							)

							env.seed(0)
							lowerCAmelCase_     :       Any								=						env.reset()
							lowerCAmelCase_     :       Any								=						0
							lowerCAmelCase_     :       Tuple								=						0
							lowerCAmelCase_     :       str								=						1000
							lowerCAmelCase_     :       int								=						[obs.copy()]
							try:
														for t in tqdm.tqdm(range(T)):
																					# call the policy
																					lowerCAmelCase_     :       int								=						pipeline(obs, planning_horizon=32)

																					# execute action in environment
																					lowerCAmelCase_			,							lowerCAmelCase_			,							lowerCAmelCase_			,							lowerCAmelCase_     :       Union[str, Any]								=						env.step(denorm_actions)
																					lowerCAmelCase_     :       Optional[int]								=						env.get_normalized_score(total_reward)

																					# update return
																					total_reward += reward
																					total_score += score
																					print(
																					    f'Step: {t}, Reward: {reward}, Total Reward: {total_reward}, Score: {score}, Total Score:'
																					    f' {total_score}'
																					)

																					# save observations for rendering
																					rollout.append(next_observation.copy())

																					lowerCAmelCase_     :       Union[str, Any]								=						next_observation
							except KeyboardInterrupt:
														pass

							print(f'Total reward: {total_reward}')




