
'''simple docstring'''
from collections.abc import Iterator, MutableMapping
from dataclasses import dataclass
from typing import Generic, TypeVar

lowercase__											=TypeVar('KEY')
lowercase__											=TypeVar('VAL')







@dataclass(frozen=UpperCamelCase__		,  slots=UpperCamelCase__					)
class   a_ (      Generic[KEY, VAL]					):
			lowerCamelCase__	:			KEY
			lowerCamelCase__	:			VAL







class   a_ (      _Item					):




			def __init__(       self	):
				super().__init__(UpperCAmelCase					,   UpperCAmelCase	)






			def __bool__(       self	):
				return False







lowercase__											=_DeletedItem()







class   a_ (      MutableMapping[KEY, VAL]					):




			def __init__(       self					,   UpperCAmelCase = 8					,   UpperCAmelCase = 0.75	):
				a_      				=						initial_block_size
				a_      				=						[None] * initial_block_size
				assert 0.0 < capacity_factor < 1.0
				a_      				=						capacity_factor
				a_      				=						0




			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				return hash(UpperCAmelCase	) % len(self._buckets	)




			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				return (ind + 1) % len(self._buckets	)




			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase	):
				a_      				=						self._buckets[ind]
				if not stored:
					a_      				=						_Item(UpperCAmelCase					,   UpperCAmelCase	)
					self._len += 1
					return True
				elif stored.key == key:
					a_      				=						_Item(UpperCAmelCase					,   UpperCAmelCase	)
					return True
				else:
					return False




			def 					lowerCAmelCase__					(       self	):
				a_      				=						len(self._buckets	) * self._capacity_factor
				return len(self	) >= int(UpperCAmelCase	)




			def 					lowerCAmelCase__					(       self	):
				if len(self._buckets	) <= self._initial_block_size:
					return False
				a_      				=						len(self._buckets	) * self._capacity_factor / 2
				return len(self	) < limit




			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				a_      				=						self._buckets
				a_      				=						[None] * new_size
				a_      				=						0
				for item in old_buckets:
					if item:
						self._add_item(item.key					,   item.val	)




			def 					lowerCAmelCase__					(       self	):
				self._resize(len(self._buckets	) * 2	)




			def 					lowerCAmelCase__					(       self	):
				self._resize(len(self._buckets	) // 2	)




			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase	):
				a_      				=						self._get_bucket_index(UpperCAmelCase	)
				for _ in range(len(self._buckets	)	):
					yield ind
					a_      				=						self._get_next_ind(UpperCAmelCase	)




			def 					lowerCAmelCase__					(       self					,   UpperCAmelCase					,   UpperCAmelCase	):
				for ind in self._iterate_buckets(UpperCAmelCase	):
					if self._try_set(UpperCAmelCase					,   UpperCAmelCase					,   UpperCAmelCase	):
						break




			def __setitem__(       self					,   UpperCAmelCase					,   UpperCAmelCase	):
				if self._is_full():
					self._size_up()

				self._add_item(UpperCAmelCase					,   UpperCAmelCase	)




			def __delitem__(       self					,   UpperCAmelCase	):
				for ind in self._iterate_buckets(UpperCAmelCase	):
					a_      				=						self._buckets[ind]
					if item is None:
						raise KeyError(UpperCAmelCase	)
					if item is _deleted:
						continue
					if item.key == key:
						a_      				=						_deleted
						self._len -= 1
						break
				if self._is_sparse():
					self._size_down()




			def __getitem__(       self					,   UpperCAmelCase	):
				for ind in self._iterate_buckets(UpperCAmelCase	):
					a_      				=						self._buckets[ind]
					if item is None:
						break
					if item is _deleted:
						continue
					if item.key == key:
						return item.val
				raise KeyError(UpperCAmelCase	)




			def __len__(       self	):
				return self._len




			def __iter__(       self	):
				yield from (item.key for item in self._buckets if item)






			def __repr__(       self	):
				a_      				=						""" ,""".join(
				    f'''{item.key}: {item.val}''' for item in self._buckets if item	)
				return f'''HashMap({val_string})'''


'''simple docstring'''
def      UpperCamelCase_				(      A__						):
	if len(A__						) <= 1:
		return lst

	a_      				=						1

	while i < len(A__						):
		if lst[i - 1] <= lst[i]:
			i += 1
		else:
			a_				,  a_      				=						lst[i], lst[i - 1]
			i -= 1
			if i == 0:
				a_      				=						1

	return lst


if __name__ == "__main__":
		lowercase__											=input('Enter numbers separated by a comma:\n').strip()
		lowercase__											=[int(item) for item in user_input.split(',')]
		print(gnome_sort(unsorted))
