"""simple docstring"""
SCREAMING_SNAKE_CASE__   =					range(2, 20 + 1)
SCREAMING_SNAKE_CASE__   =					[10**k for k in range(ks[-1] + 1)]
SCREAMING_SNAKE_CASE__   =					{}





def 				lowerCAmelCase__      (     _UpperCamelCase    :			str	,     _UpperCamelCase    :			str	,     _UpperCamelCase    :			List[str]	,     _UpperCamelCase    :			Optional[Any]   )   ->			Tuple:





						"""simple docstring"""






						snake_case        =     sum(a_i[j] for j in range(_UpperCamelCase	,     len(_UpperCamelCase   )   )   )
						snake_case        =     sum(a_i[j] * base[j] for j in range(min(len(_UpperCamelCase   )	,     _UpperCamelCase   )   )   )

						snake_case   ,snake_case        =     0, 0
						snake_case        =     n - i

						snake_case        =     memo.get(_UpperCamelCase   )

						if sub_memo is not None:
												snake_case        =     sub_memo.get(_UpperCamelCase   )

												if jumps is not None and len(_UpperCamelCase   ) > 0:
																		# find and make the largest jump without going over
																		snake_case        =     -1
																		for _k in range(len(_UpperCamelCase   ) - 1	,     -1	,     -1   ):
																								if jumps[_k][2] <= k and jumps[_k][1] <= max_dn:
																														snake_case        =     _k
																														break

																		if max_jump >= 0:
																								snake_case   ,snake_case   ,snake_case        =     jumps[max_jump]
																								# since the difference between jumps is cached, add c
																								snake_case        =     diff + c
																								for j in range(min(_UpperCamelCase	,     len(_UpperCamelCase   )   )   ):
																														snake_case   ,snake_case        =     divmod(_UpperCamelCase	,     1_0   )
																								if new_c > 0:
																														add(_UpperCamelCase	,     _UpperCamelCase	,     _UpperCamelCase   )

												else:
																		snake_case        =     []
						else:
												snake_case        =     {c: []}
												snake_case        =     sub_memo

						if dn >= max_dn or c + diff >= base[k]:
												return diff, dn

						if k > ks[0]:
												while True:
																		# keep doing smaller jumps
																		snake_case   ,snake_case        =     next_term(_UpperCamelCase	,     k - 1	,     i + dn	,     _UpperCamelCase   )
																		diff += _diff
																		dn += terms_jumped

																		if dn >= max_dn or c + diff >= base[k]:
																								break
						else:
												# would be too small a jump, just compute sequential terms instead
												snake_case   ,snake_case        =     compute(_UpperCamelCase	,     _UpperCamelCase	,     i + dn	,     _UpperCamelCase   )
												diff += _diff
												dn += terms_jumped

						snake_case        =     sub_memo[c]

						# keep jumps sorted by # of terms skipped
						snake_case        =     0
						while j < len(_UpperCamelCase   ):
												if jumps[j][1] > dn:
																		break
												j += 1

						# cache the jump for this value digitsum(b) and c
						sub_memo[c].insert(_UpperCamelCase	,     (diff, dn, k)   )
						return (diff, dn)





def 				lowerCAmelCase__      (     _UpperCamelCase    :			Dict	,     _UpperCamelCase    :			Union[str, Any]	,     _UpperCamelCase    :			Optional[Any]	,     _UpperCamelCase    :			Tuple   )   ->			List[Any]:





						"""simple docstring"""






						if i >= n:
												return 0, i
						if k > len(_UpperCamelCase   ):
												a_i.extend([0 for _ in range(k - len(_UpperCamelCase   )   )]   )

						# note: a_i -> b * 10^k + c
						# ds_b -> digitsum(b)
						# ds_c -> digitsum(c)
						snake_case        =     i
						snake_case   ,snake_case   ,snake_case        =     0, 0, 0
						for j in range(len(_UpperCamelCase   )   ):
												if j >= k:
																		ds_b += a_i[j]
												else:
																		ds_c += a_i[j]

						while i < n:
												i += 1
												snake_case        =     ds_c + ds_b
												diff += addend
												snake_case        =     0
												for j in range(_UpperCamelCase   ):
																		snake_case        =     a_i[j] + addend
																		snake_case   ,snake_case        =     divmod(_UpperCamelCase	,     1_0   )

																		ds_c += a_i[j]

												if addend > 0:
																		break

						if addend > 0:
												add(_UpperCamelCase	,     _UpperCamelCase	,     _UpperCamelCase   )
						return diff, i - start_i





def 				lowerCAmelCase__      (     _UpperCamelCase    :			Tuple	,     _UpperCamelCase    :			str	,     _UpperCamelCase    :			List[str]   )   ->			Tuple:





						"""simple docstring"""






						for j in range(_UpperCamelCase	,     len(_UpperCamelCase   )   ):
												snake_case        =     digits[j] + addend
												if s >= 1_0:
																		snake_case   ,snake_case        =     divmod(_UpperCamelCase	,     1_0   )
																		snake_case        =     addend // 1_0 + quotient
												else:
																		snake_case        =     s
																		snake_case        =     addend // 1_0

												if addend == 0:
																		break

						while addend > 0:
												snake_case   ,snake_case        =     divmod(_UpperCamelCase	,     1_0   )
												digits.append(_UpperCamelCase   )





def 				lowerCAmelCase__      (     _UpperCamelCase    :			int = 1_0**1_5   )   ->			int:





						"""simple docstring"""






						snake_case        =     [1]
						snake_case        =     1
						snake_case        =     0
						while True:
												snake_case   ,snake_case        =     next_term(_UpperCamelCase	,     2_0	,     i + dn	,     _UpperCamelCase   )
												dn += terms_jumped
												if dn == n - i:
																		break

						snake_case        =     0
						for j in range(len(_UpperCamelCase   )   ):
												a_n += digits[j] * 1_0**j
						return a_n


if __name__ == "__main__":
					print(f"""{solution() = }""")



"""simple docstring"""
def 				lowerCAmelCase__      (     _UpperCamelCase    :			str   )   ->			bool:





						"""simple docstring"""






						if not all(x.isalpha() for x in string   ):
												raise ValueError('String must only contain alphabetic characters.'   )

						snake_case        =     sorted(string.lower()   )
						return len(_UpperCamelCase   ) == len(set(_UpperCamelCase   )   )


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

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


