




import copy
import re




class 					snake_case__							:
				"""simple docstring"""



				SCREAMING_SNAKE_CASE_ :							List[str]											=      """hp"""
				SCREAMING_SNAKE_CASE_ :							str											=      {}
				SCREAMING_SNAKE_CASE_ :							Dict											=      None





				@classmethod
				def 							__UpperCAmelCase							(   cls       :  Any      ,   __lowerCamelCase       :  Optional[int]      ,   __lowerCamelCase       :  Optional[int]							)      ->  Dict:
							a					=    prefix
							a					=    defaults
							cls.build_naming_info()





				@staticmethod
				def 							__UpperCAmelCase							(   __lowerCamelCase       :  Optional[Any]      ,   __lowerCamelCase       :  Union[str, Any]							)      ->  Union[str, Any]:
							if len(__lowerCamelCase							) == 0:
										return ""
							a					=    None
							if any(char.isdigit() for char in word							):
										raise Exception(f"""Parameters should not contain numbers: '{word}' contains a number"""							)
							if word in info["short_word"]:
										return info["short_word"][word]
							for prefix_len in range(1      ,   len(__lowerCamelCase							) + 1							):
										a					=    word[:prefix_len]
										if prefix in info["reverse_short_word"]:
													continue
										else:
													a					=    prefix
													break

							if short_word is None:
										# Paranoid fallback
										def int_to_alphabetic(__lowerCamelCase       :  Union[str, Any]							):
													a					=    ""
													while integer != 0:
																a					=    chr(ord("A"							) + integer % 10							) + s
																integer //= 10
													return s

										a					=    0
										while True:
													a					=    word + "#" + int_to_alphabetic(__lowerCamelCase							)
													if sword in info["reverse_short_word"]:
																continue
													else:
																a					=    sword
																break

							a					=    short_word
							a					=    word
							return short_word





				@staticmethod
				def 							__UpperCAmelCase							(   __lowerCamelCase       :  List[str]      ,   __lowerCamelCase       :  Optional[int]							)      ->  List[Any]:
							a					=    param_name.split("_"							)

							a					=    [TrialShortNamer.shortname_for_word(__lowerCamelCase      ,   __lowerCamelCase							) for word in words]

							# We try to create a separatorless short name, but if there is a collision we have to fallback
							# to a separated short name
							a					=    ["", "_"]

							for separator in separators:
										a					=    separator.join(__lowerCamelCase							)
										if shortname not in info["reverse_short_param"]:
													a					=    shortname
													a					=    param_name
													return shortname

							return param_name





				@staticmethod
				def 							__UpperCAmelCase							(   __lowerCamelCase       :  int      ,   __lowerCamelCase       :  str							)      ->  Optional[int]:
							a					=    TrialShortNamer.shortname_for_key(__lowerCamelCase      ,   __lowerCamelCase							)
							a					=    short_name
							a					=    param_name





				@classmethod
				def 							__UpperCAmelCase							(   cls       :  str							)      ->  Union[str, Any]:
							if cls.NAMING_INFO is not None:
										return

							a					=    {
							    "short_word": {},
							    "reverse_short_word": {},
							    "short_param": {},
							    "reverse_short_param": {},
							}

							a					=    list(cls.DEFAULTS.keys()							)

							for k in field_keys:
										cls.add_new_param_name(__lowerCamelCase      ,   __lowerCamelCase							)

							a					=    info





				@classmethod
				def 							__UpperCAmelCase							(   cls       :  List[str]      ,   __lowerCamelCase       :  Any							)      ->  Any:
							cls.build_naming_info()
							assert cls.PREFIX is not None
							a					=    [copy.copy(cls.PREFIX							)]

							for k, v in params.items():
										if k not in cls.DEFAULTS:
													raise Exception(f"""You should provide a default value for the param name {k} with value {v}"""							)
										if v == cls.DEFAULTS[k]:
													# The default value is not added to the name
													continue

										a					=    cls.NAMING_INFO["short_param"][k]

										if isinstance(__lowerCamelCase      ,   __lowerCamelCase							):
													a					=    1 if v else 0

										a					=    "" if isinstance(__lowerCamelCase      ,   (int, float)							) else "-"
										a					=    f"""{key}{sep}{v}"""
										name.append(__lowerCamelCase							)

							return "_".join(__lowerCamelCase							)





				@classmethod
				def 							__UpperCAmelCase							(   cls       :  Dict      ,   __lowerCamelCase       :  Optional[Any]							)      ->  Tuple:
							a					=    repr[len(cls.PREFIX							) + 1 :]
							if repr == "":
										a					=    []
							else:
										a					=    repr.split("_"							)

							a					=    {}

							for value in values:
										if "-" in value:
													a					,	a					=    value.split("-"							)
										else:
													a					=    re.sub("[0-9.]"      ,   ""      ,   __lowerCamelCase							)
													a					=    float(re.sub("[^0-9.]"      ,   ""      ,   __lowerCamelCase							)							)

										a					=    cls.NAMING_INFO["reverse_short_param"][p_k]

										a					=    p_v

							for k in cls.DEFAULTS:
										if k not in parameters:
													a					=    cls.DEFAULTS[k]

							return parameters












__lowerCAmelCase	:       List[Any]     =	{str(digit): digit**5 for digit in range(10)}




def     __magic_name__       (				A	:      int     ):






			'''simple docstring'''







			return sum(DIGITS_FIFTH_POWER[digit] for digit in str(A     )     )




def     __magic_name__       (				):






			'''simple docstring'''







			return sum(
			    number
			    for number in range(1000,						1000000     )
			    if number == digits_fifth_powers_sum(A     )     )


if __name__ == "__main__":
		print(solution())






