


"""simple docstring"""






def  lowerCAmelCase_      (_SCREAMING_SNAKE_CASE	:int		,			_SCREAMING_SNAKE_CASE	:int = 1000  )				-> str:
						if (not isinstance(_SCREAMING_SNAKE_CASE		,			_SCREAMING_SNAKE_CASE  )) or (digit_position <= 0):
												raise ValueError("Digit position must be a positive integer"  )
						elif (not isinstance(_SCREAMING_SNAKE_CASE		,			_SCREAMING_SNAKE_CASE  )) or (precision < 0):
												raise ValueError("Precision must be a nonnegative integer"  )

						# compute an approximation of (16 ** (n - 1)) * pi whose fractional part is mostly
						# accurate
						a_							:			Optional[Any]     		=					(
						    4 * _subsum(_SCREAMING_SNAKE_CASE		,			1		,			_SCREAMING_SNAKE_CASE  )
						    - 2 * _subsum(_SCREAMING_SNAKE_CASE		,			4		,			_SCREAMING_SNAKE_CASE  )
						    - _subsum(_SCREAMING_SNAKE_CASE		,			5		,			_SCREAMING_SNAKE_CASE  )
						    - _subsum(_SCREAMING_SNAKE_CASE		,			6		,			_SCREAMING_SNAKE_CASE  )
						)

						# return the first hex digit of the fractional part of the result
						return hex(int((sum_result % 1) * 16  )  )[2:]

def  lowerCAmelCase_      (_SCREAMING_SNAKE_CASE	:int		,			_SCREAMING_SNAKE_CASE	:int		,			_SCREAMING_SNAKE_CASE	:int  )				-> float:
						a_							:			Optional[Any]     		=					0.0
						for sum_index in range(digit_pos_to_extract + precision  ):
												a_							:			Union[str, Any]     		=					8 * sum_index + denominator_addend
												if sum_index < digit_pos_to_extract:
																		# if the exponential term is an integer and we mod it by the denominator
																		# before dividing, only the integer part of the sum will change;
																		# the fractional part will not
																		a_							:			int     		=					pow(
																		    16		,			digit_pos_to_extract - 1 - sum_index		,			_SCREAMING_SNAKE_CASE  )
												else:
																		a_							:			Tuple     		=					pow(16		,			digit_pos_to_extract - 1 - sum_index  )
												total += exponential_term / denominator
						return total


if __name__ == "__main__":
				import doctest

				doctest.testmod()





"""simple docstring"""






def  lowerCAmelCase_      (_SCREAMING_SNAKE_CASE	:int  )				-> Optional[int]:
						a_							:			List[Any]     		=					len(_SCREAMING_SNAKE_CASE  )
						for _ in range(
						    0		,			int(((no_of_elements - 1) / 2) + 1  )  ):  # we don't need to traverse to end of list as
												for j in range(0		,			no_of_elements - 1  ):
																		if (
																		    lst[j + 1] < lst[j]
																		):  # applying bubble sort algorithm from left to right (or forwards)
																								a_							:			List[str]     		=					lst[j + 1]
																								a_							:			Optional[Any]     		=					lst[j]
																								a_							:			Optional[Any]     		=					temp
																		if (
																		    lst[no_of_elements - 1 - j] < lst[no_of_elements - 2 - j]
																		):  # applying bubble sort algorithm from right to left (or backwards)
																								a_							:			Dict     		=					lst[no_of_elements - 1 - j]
																								a_							:			Dict     		=					lst[no_of_elements - 2 - j]
																								a_							:			Any     		=					temp
						return lst


if __name__ == "__main__":
				print('enter the list to be sorted')
				UpperCamelCase     					=     [int(x) for x in input().split()]  # inputing elements of the list in one line
				UpperCamelCase     					=     double_sort(lst)
				print('the sorted list is')
				print(sorted_lst)




