



'''simple docstring'''

import copy
import re

class       __magic_name__		:
							lowerCAmelCase			:       Any  							=   'hp'
							lowerCAmelCase			:       int  							=   {}
							lowerCAmelCase			:       int  							=   None







							@classmethod
							def 				__lowercase     (				cls   :			Dict      ,_UpperCAmelCase   :			Any      ,_UpperCAmelCase   :			List[Any]						):
									_a	: Any								=				prefix
									_a	: Union[str, Any]								=				defaults
									cls.build_naming_info()







							@staticmethod
							def 				__lowercase     (				_UpperCAmelCase   :			Dict      ,_UpperCAmelCase   :			Union[str, Any]						):
									if len(_UpperCAmelCase						) == 0:
											return ""
									_a	: List[str]								=				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(_UpperCAmelCase						) + 1						):
											_a	: int								=				word[:prefix_len]
											if prefix in info["reverse_short_word"]:
													continue
											else:
													_a	: List[Any]								=				prefix
													break

									if short_word is None:
											# Paranoid fallback
											def int_to_alphabetic(_UpperCAmelCase   :			Any						):
													_a	: List[str]								=				''
													while integer != 0:
															_a	: Tuple								=				chr(ord('A'						) + integer % 10						) + s
															integer //= 10
													return s

											_a	: Optional[Any]								=				0
											while True:
													_a	: Dict								=				word + '#' + int_to_alphabetic(_UpperCAmelCase						)
													if sword in info["reverse_short_word"]:
															continue
													else:
															_a	: int								=				sword
															break

									_a	: Optional[int]								=				short_word
									_a	: Any								=				word
									return short_word







							@staticmethod
							def 				__lowercase     (				_UpperCAmelCase   :			Any      ,_UpperCAmelCase   :			Optional[int]						):
									_a	: Any								=				param_name.split('_'						)

									_a	: List[Any]								=				[TrialShortNamer.shortname_for_word(_UpperCAmelCase      ,_UpperCAmelCase						) 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	: Optional[int]								=				['', '_']

									for separator in separators:
											_a	: List[Any]								=				separator.join(_UpperCAmelCase						)
											if shortname not in info["reverse_short_param"]:
													_a	: List[str]								=				shortname
													_a	: str								=				param_name
													return shortname

									return param_name







							@staticmethod
							def 				__lowercase     (				_UpperCAmelCase   :			List[Any]      ,_UpperCAmelCase   :			List[str]						):
									_a	: Tuple								=				TrialShortNamer.shortname_for_key(_UpperCAmelCase      ,_UpperCAmelCase						)
									_a	: Optional[Any]								=				short_name
									_a	: List[Any]								=				param_name







							@classmethod
							def 				__lowercase     (				cls   :			Any						):
									if cls.NAMING_INFO is not None:
											return

									_a	: Optional[Any]								=				{
									    'short_word': {},
									    'reverse_short_word': {},
									    'short_param': {},
									    'reverse_short_param': {},
									}

									_a	: Union[str, Any]								=				list(cls.DEFAULTS.keys()						)

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

									_a	: Union[str, Any]								=				info







							@classmethod
							def 				__lowercase     (				cls   :			int      ,_UpperCAmelCase   :			Any						):
									cls.build_naming_info()
									assert cls.PREFIX is not None
									_a	: Union[str, Any]								=				[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	: Union[str, Any]								=				cls.NAMING_INFO['short_param'][k]

											if isinstance(_UpperCAmelCase      ,_UpperCAmelCase						):
													_a	: int								=				1 if v else 0

											_a	: str								=				'' if isinstance(_UpperCAmelCase      ,(int, float)						) else '-'
											_a	: Union[str, Any]								=				F"""{key}{sep}{v}"""
											name.append(_UpperCAmelCase						)

									return "_".join(_UpperCAmelCase						)







							@classmethod
							def 				__lowercase     (				cls   :			str      ,_UpperCAmelCase   :			Optional[int]						):
									_a	: Optional[int]								=				repr[len(cls.PREFIX						) + 1 :]
									if repr == "":
											_a	: Tuple								=				[]
									else:
											_a	: Optional[int]								=				repr.split('_'						)

									_a	: Dict								=				{}

									for value in values:
											if "-" in value:
													_a			,   _a	: Optional[int]								=				value.split('-'						)
											else:
													_a	: Any								=				re.sub('[0-9.]'      ,''      ,_UpperCAmelCase						)
													_a	: Optional[int]								=				float(re.sub('[^0-9.]'      ,''      ,_UpperCAmelCase						)						)

											_a	: int								=				cls.NAMING_INFO['reverse_short_param'][p_k]

											_a	: Any								=				p_v

									for k in cls.DEFAULTS:
											if k not in parameters:
													_a	: Optional[Any]								=				cls.DEFAULTS[k]

									return parameters









'''simple docstring'''

def 	__lowerCamelCase	( lowerCAmelCase_    )     -> bool:
		if not all(x.isalpha() for x in string    ):
				raise ValueError('String must only contain alphabetic characters.'    )

		_a	: Tuple								=				sorted(string.lower()    )
		return len(lowerCAmelCase_    ) == len(set(lowerCAmelCase_    )    )


if __name__ == "__main__":
							__lowerCAmelCase		     =  input('''Enter a string ''').strip()

							__lowerCAmelCase		     =  is_isogram(input_str)
							print(f"""{input_str} is {'an' if isogram else 'not an'} isogram.""")




