def    lowerCAmelCase_  (		lowercase:				Union[str, Any]		)     ->					Union[str, Any]:







 '''simple docstring'''
 _UpperCamelCase:  str    						=			int(__a		)
 if n_element < 1:
  _UpperCamelCase:  List[Any]    						=			ValueError('''a should be a positive number'''		)
  raise my_error

 _UpperCamelCase:  List[Any]    						=			[1]
 _UpperCamelCase						,				_UpperCamelCase						,				_UpperCamelCase:  int    						=			(0, 0, 0)
 _UpperCamelCase:  List[Any]    						=			1
 while index < n_element:
  while hamming_list[i] * 2 <= hamming_list[-1]:
   i += 1
  while hamming_list[j] * 3 <= hamming_list[-1]:
   j += 1
  while hamming_list[k] * 5 <= hamming_list[-1]:
   k += 1
  hamming_list.append(
      min(hamming_list[i] * 2	,       hamming_list[j] * 3	,       hamming_list[k] * 5		)		)
  index += 1
 return hamming_list


if __name__ == "__main__":
  UpperCAmelCase_           =				input('''Enter the last number (nth term) of the Hamming Number Series: ''')
  print('''Formula of Hamming Number Series => 2^i * 3^j * 5^k''')
  UpperCAmelCase_           =				hamming(int(n))
  print('''-----------------------------------------------------''')
  print(f"""The list with nth numbers is: {hamming_numbers}""")
  print('''-----------------------------------------------------''')

"""simple docstring"""





import operator
def 				A_  (__a					, __a = False					, __a = None					):

					'''simple docstring'''





					A_								=    operator.lt if reverse else operator.gt
					A_								=    solution or []

					if not arr:
										return solution

					A_								=    [arr.pop(0					)]
					for i, item in enumerate(__a					):
										if _operator(__a					, sublist[-1]					):
															sublist.append(__a					)
															arr.pop(__a					)

    #  merging sublist into solution list
					if not solution:
										solution.extend(__a					)
					else:
										while sublist:
															A_								=    sublist.pop(0					)
															for i, xx in enumerate(__a					):
																				if not _operator(__a					, __a					):
																									solution.insert(__a					, __a					)
																									break
															else:
																				solution.append(__a					)

					strand_sort(__a					, __a					, __a					)
					return solution


if __name__ == "__main__":
		assert strand_sort([4, 3, 5, 1, 2]) == [1, 2, 3, 4, 5]
		assert strand_sort([4, 3, 5, 1, 2], reverse=True) == [5, 4, 3, 2, 1]




