


def 			__SCREAMING_SNAKE_CASE		(		UpperCamelCase		:      int = 100	)     ->	int:



	"""simple docstring"""






	a_     			=   1
	a_     			=   0
	for i in range(1     ,					num + 1	):
		fact *= i

	for j in str(UpperCamelCase	):
		result += int(UpperCamelCase	)

	return result


if __name__ == "__main__":
			print(solution(int(input('Enter the Number: ').strip())))



import tempfile

import torch

from diffusers import (
    DEISMultistepScheduler,
    DPMSolverMultistepScheduler,
    DPMSolverSinglestepScheduler,
    UniPCMultistepScheduler,
)

from .test_schedulers import SchedulerCommonTest

class 			lowerCamelCase_					(    _SCREAMING_SNAKE_CASE    ):
							_lowerCamelCase				: Optional[int]       =					(DPMSolverMultistepScheduler,)
							_lowerCamelCase				: Optional[Any]       =					(("""num_inference_steps""", 25),)





							def   __magic_name__      (							self			,       **_SCREAMING_SNAKE_CASE    ):
								a_     			=   {
								    """num_train_timesteps""": 1000,
								    """beta_start""": 0.0_0_0_1,
								    """beta_end""": 0.0_2,
								    """beta_schedule""": """linear""",
								    """solver_order""": 2,
								    """prediction_type""": """epsilon""",
								    """thresholding""": False,
								    """sample_max_value""": 1.0,
								    """algorithm_type""": """dpmsolver++""",
								    """solver_type""": """midpoint""",
								    """lower_order_final""": False,
								    """lambda_min_clipped""": -float("""inf"""    ),
								    """variance_type""": None,
								}

								config.update(**_SCREAMING_SNAKE_CASE    )
								return config





							def   __magic_name__      (							self			,       _SCREAMING_SNAKE_CASE=0			,       **_SCREAMING_SNAKE_CASE    ):
								a_     			=   dict(self.forward_default_kwargs    )
								a_     			=   kwargs.pop("""num_inference_steps"""			,       _SCREAMING_SNAKE_CASE    )
								a_     			=   self.dummy_sample
								a_     			=   0.1 * sample
								a_     			=   [residual + 0.2, residual + 0.1_5, residual + 0.1_0]

								for scheduler_class in self.scheduler_classes:
									a_     			=   self.get_scheduler_config(**_SCREAMING_SNAKE_CASE    )
									a_     			=   scheduler_class(**_SCREAMING_SNAKE_CASE    )
									scheduler.set_timesteps(_SCREAMING_SNAKE_CASE    )
									# copy over dummy past residuals
									a_     			=   dummy_past_residuals[: scheduler.config.solver_order]

									with tempfile.TemporaryDirectory() as tmpdirname:
										scheduler.save_config(_SCREAMING_SNAKE_CASE    )
										a_     			=   scheduler_class.from_pretrained(_SCREAMING_SNAKE_CASE    )
										new_scheduler.set_timesteps(_SCREAMING_SNAKE_CASE    )
										# copy over dummy past residuals
										a_     			=   dummy_past_residuals[: new_scheduler.config.solver_order]

									a_			, a_     			=   sample, sample
									for t in range(_SCREAMING_SNAKE_CASE			,       time_step + scheduler.config.solver_order + 1    ):
										a_     			=   scheduler.step(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       **_SCREAMING_SNAKE_CASE    ).prev_sample
										a_     			=   new_scheduler.step(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       **_SCREAMING_SNAKE_CASE    ).prev_sample

										assert torch.sum(torch.abs(output - new_output    )    ) < 1E-5, "Scheduler outputs are not identical"





							def   __magic_name__      (							self    ):
								pass





							def   __magic_name__      (							self			,       _SCREAMING_SNAKE_CASE=0			,       **_SCREAMING_SNAKE_CASE    ):
								a_     			=   dict(self.forward_default_kwargs    )
								a_     			=   kwargs.pop("""num_inference_steps"""			,       _SCREAMING_SNAKE_CASE    )
								a_     			=   self.dummy_sample
								a_     			=   0.1 * sample
								a_     			=   [residual + 0.2, residual + 0.1_5, residual + 0.1_0]

								for scheduler_class in self.scheduler_classes:
									a_     			=   self.get_scheduler_config()
									a_     			=   scheduler_class(**_SCREAMING_SNAKE_CASE    )
									scheduler.set_timesteps(_SCREAMING_SNAKE_CASE    )

									# copy over dummy past residuals (must be after setting timesteps)
									a_     			=   dummy_past_residuals[: scheduler.config.solver_order]

									with tempfile.TemporaryDirectory() as tmpdirname:
										scheduler.save_config(_SCREAMING_SNAKE_CASE    )
										a_     			=   scheduler_class.from_pretrained(_SCREAMING_SNAKE_CASE    )
										# copy over dummy past residuals
										new_scheduler.set_timesteps(_SCREAMING_SNAKE_CASE    )

										# copy over dummy past residual (must be after setting timesteps)
										a_     			=   dummy_past_residuals[: new_scheduler.config.solver_order]

									a_     			=   scheduler.step(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       **_SCREAMING_SNAKE_CASE    ).prev_sample
									a_     			=   new_scheduler.step(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       **_SCREAMING_SNAKE_CASE    ).prev_sample

									assert torch.sum(torch.abs(output - new_output    )    ) < 1E-5, "Scheduler outputs are not identical"





							def   __magic_name__      (							self			,       _SCREAMING_SNAKE_CASE=None			,       **_SCREAMING_SNAKE_CASE    ):
								if scheduler is None:
									a_     			=   self.scheduler_classes[0]
									a_     			=   self.get_scheduler_config(**_SCREAMING_SNAKE_CASE    )
									a_     			=   scheduler_class(**_SCREAMING_SNAKE_CASE    )

								a_     			=   10
								a_     			=   self.dummy_model()
								a_     			=   self.dummy_sample_deter
								scheduler.set_timesteps(_SCREAMING_SNAKE_CASE    )

								for i, t in enumerate(scheduler.timesteps    ):
									a_     			=   model(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE    )
									a_     			=   scheduler.step(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE    ).prev_sample

								return sample





							def   __magic_name__      (							self    ):
								a_     			=   dict(self.forward_default_kwargs    )

								a_     			=   kwargs.pop("""num_inference_steps"""			,       _SCREAMING_SNAKE_CASE    )

								for scheduler_class in self.scheduler_classes:
									a_     			=   self.get_scheduler_config()
									a_     			=   scheduler_class(**_SCREAMING_SNAKE_CASE    )

									a_     			=   self.dummy_sample
									a_     			=   0.1 * sample

									if num_inference_steps is not None and hasattr(_SCREAMING_SNAKE_CASE			,       """set_timesteps"""    ):
										scheduler.set_timesteps(_SCREAMING_SNAKE_CASE    )
									elif num_inference_steps is not None and not hasattr(_SCREAMING_SNAKE_CASE			,       """set_timesteps"""    ):
										a_     			=   num_inference_steps

									# copy over dummy past residuals (must be done after set_timesteps)
									a_     			=   [residual + 0.2, residual + 0.1_5, residual + 0.1_0]
									a_     			=   dummy_past_residuals[: scheduler.config.solver_order]

									a_     			=   scheduler.timesteps[5]
									a_     			=   scheduler.timesteps[6]

									a_     			=   scheduler.step(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       **_SCREAMING_SNAKE_CASE    ).prev_sample
									a_     			=   scheduler.step(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       **_SCREAMING_SNAKE_CASE    ).prev_sample

									self.assertEqual(output_a.shape			,       sample.shape    )
									self.assertEqual(output_a.shape			,       output_a.shape    )





							def   __magic_name__      (							self    ):
								for timesteps in [25, 50, 100, 999, 1000]:
									self.check_over_configs(num_train_timesteps=_SCREAMING_SNAKE_CASE    )





							def   __magic_name__      (							self    ):
								self.check_over_configs(thresholding=_SCREAMING_SNAKE_CASE    )
								for order in [1, 2, 3]:
									for solver_type in ["midpoint", "heun"]:
										for threshold in [0.5, 1.0, 2.0]:
											for prediction_type in ["epsilon", "sample"]:
												self.check_over_configs(
												    thresholding=_SCREAMING_SNAKE_CASE			,       prediction_type=_SCREAMING_SNAKE_CASE			,       sample_max_value=_SCREAMING_SNAKE_CASE			,       algorithm_type="""dpmsolver++"""			,       solver_order=_SCREAMING_SNAKE_CASE			,       solver_type=_SCREAMING_SNAKE_CASE			,       )





							def   __magic_name__      (							self    ):
								for prediction_type in ["epsilon", "v_prediction"]:
									self.check_over_configs(prediction_type=_SCREAMING_SNAKE_CASE    )





							def   __magic_name__      (							self    ):
								for algorithm_type in ["dpmsolver", "dpmsolver++", "sde-dpmsolver", "sde-dpmsolver++"]:
									for solver_type in ["midpoint", "heun"]:
										for order in [1, 2, 3]:
											for prediction_type in ["epsilon", "sample"]:
												if algorithm_type in ["sde-dpmsolver", "sde-dpmsolver++"]:
													if order == 3:
														continue
												else:
													self.check_over_configs(
													    solver_order=_SCREAMING_SNAKE_CASE			,       solver_type=_SCREAMING_SNAKE_CASE			,       prediction_type=_SCREAMING_SNAKE_CASE			,       algorithm_type=_SCREAMING_SNAKE_CASE			,       )
												a_     			=   self.full_loop(
												    solver_order=_SCREAMING_SNAKE_CASE			,       solver_type=_SCREAMING_SNAKE_CASE			,       prediction_type=_SCREAMING_SNAKE_CASE			,       algorithm_type=_SCREAMING_SNAKE_CASE			,       )
												assert not torch.isnan(_SCREAMING_SNAKE_CASE    ).any(), "Samples have nan numbers"





							def   __magic_name__      (							self    ):
								self.check_over_configs(lower_order_final=_SCREAMING_SNAKE_CASE    )
								self.check_over_configs(lower_order_final=_SCREAMING_SNAKE_CASE    )





							def   __magic_name__      (							self    ):
								self.check_over_configs(lambda_min_clipped=-float("""inf"""    )    )
								self.check_over_configs(lambda_min_clipped=-5.1    )





							def   __magic_name__      (							self    ):
								self.check_over_configs(variance_type=_SCREAMING_SNAKE_CASE    )
								self.check_over_configs(variance_type="""learned_range"""    )





							def   __magic_name__      (							self    ):
								for num_inference_steps in [1, 2, 3, 5, 10, 50, 100, 999, 1000]:
									self.check_over_forward(num_inference_steps=_SCREAMING_SNAKE_CASE			,       time_step=0    )





							def   __magic_name__      (							self    ):
								a_     			=   self.full_loop()
								a_     			=   torch.mean(torch.abs(_SCREAMING_SNAKE_CASE    )    )

								assert abs(result_mean.item() - 0.3_3_0_1    ) < 1E-3





							def   __magic_name__      (							self    ):
								a_     			=   self.full_loop(thresholding=_SCREAMING_SNAKE_CASE			,       dynamic_thresholding_ratio=0.8_7			,       sample_max_value=0.5    )
								a_     			=   torch.mean(torch.abs(_SCREAMING_SNAKE_CASE    )    )

								assert abs(result_mean.item() - 1.1_3_6_4    ) < 1E-3





							def   __magic_name__      (							self    ):
								a_     			=   self.full_loop(prediction_type="""v_prediction"""    )
								a_     			=   torch.mean(torch.abs(_SCREAMING_SNAKE_CASE    )    )

								assert abs(result_mean.item() - 0.2_2_5_1    ) < 1E-3





							def   __magic_name__      (							self    ):
								a_     			=   self.full_loop(prediction_type="""v_prediction"""			,       use_karras_sigmas=_SCREAMING_SNAKE_CASE    )
								a_     			=   torch.mean(torch.abs(_SCREAMING_SNAKE_CASE    )    )

								assert abs(result_mean.item() - 0.2_0_9_6    ) < 1E-3





							def   __magic_name__      (							self    ):
								# make sure that iterating over schedulers with same config names gives same results
								# for defaults
								a_     			=   DPMSolverMultistepScheduler(**self.get_scheduler_config()    )
								a_     			=   self.full_loop(scheduler=_SCREAMING_SNAKE_CASE    )
								a_     			=   torch.mean(torch.abs(_SCREAMING_SNAKE_CASE    )    )

								assert abs(result_mean.item() - 0.3_3_0_1    ) < 1E-3

								a_     			=   DPMSolverSinglestepScheduler.from_config(scheduler.config    )
								a_     			=   UniPCMultistepScheduler.from_config(scheduler.config    )
								a_     			=   DEISMultistepScheduler.from_config(scheduler.config    )
								a_     			=   DPMSolverMultistepScheduler.from_config(scheduler.config    )

								a_     			=   self.full_loop(scheduler=_SCREAMING_SNAKE_CASE    )
								a_     			=   torch.mean(torch.abs(_SCREAMING_SNAKE_CASE    )    )

								assert abs(result_mean.item() - 0.3_3_0_1    ) < 1E-3





							def   __magic_name__      (							self    ):
								a_     			=   self.scheduler_classes[0]
								a_     			=   self.get_scheduler_config(thresholding=_SCREAMING_SNAKE_CASE			,       dynamic_thresholding_ratio=0    )
								a_     			=   scheduler_class(**_SCREAMING_SNAKE_CASE    )

								a_     			=   10
								a_     			=   self.dummy_model()
								a_     			=   self.dummy_sample_deter.half()
								scheduler.set_timesteps(_SCREAMING_SNAKE_CASE    )

								for i, t in enumerate(scheduler.timesteps    ):
									a_     			=   model(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE    )
									a_     			=   scheduler.step(_SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE			,       _SCREAMING_SNAKE_CASE    ).prev_sample

								assert sample.dtype == torch.floataa





							def   __magic_name__      (							self			,       **_SCREAMING_SNAKE_CASE    ):
								for scheduler_class in self.scheduler_classes:
									a_     			=   self.get_scheduler_config(**_SCREAMING_SNAKE_CASE    )
									a_     			=   scheduler_class(**_SCREAMING_SNAKE_CASE    )

									scheduler.set_timesteps(scheduler.config.num_train_timesteps    )
									assert len(scheduler.timesteps.unique()    ) == scheduler.num_inference_steps