

def 				__SCREAMING_SNAKE_CASE				(					lowerCAmelCase:	Optional[int]			) ->							str:

				if len(__a			) < 2:
								return collection

				def circle_sort_util(lowerCAmelCase:	Optional[int]	,   lowerCAmelCase:	List[Any]	,   lowerCAmelCase:	str			) -> bool:
								_UpperCAmelCase							:		Dict					=     False

								if low == high:
												return swapped

								_UpperCAmelCase							:		str					=     low
								_UpperCAmelCase							:		Union[str, Any]					=     high

								while left < right:
												if collection[left] > collection[right]:
																_UpperCAmelCase		,				_UpperCAmelCase							:		Optional[Any]					=     (
																    collection[right],
																    collection[left],
																)
																_UpperCAmelCase							:		Optional[int]					=     True

												left += 1
												right -= 1

								if left == right and collection[left] > collection[right + 1]:
												_UpperCAmelCase		,				_UpperCAmelCase							:		int					=     (
												    collection[right + 1],
												    collection[left],
												)

												_UpperCAmelCase							:		Optional[int]					=     True

								_UpperCAmelCase							:		Optional[Any]					=     low + int((high - low) / 2			)
								_UpperCAmelCase							:		List[str]					=     circle_sort_util(__a	,   __a	,   __a			)
								_UpperCAmelCase							:		Union[str, Any]					=     circle_sort_util(__a	,   mid + 1	,   __a			)

								return swapped or left_swap or right_swap

				_UpperCAmelCase							:		Dict					=     True

				while is_not_sorted is True:
								_UpperCAmelCase							:		Any					=     circle_sort_util(__a	,   0	,   len(__a			) - 1			)

				return collection


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




"""simple docstring"""




import doctest
from collections import deque

import numpy as np





class 			snake_case  :

							def __init__(self     ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_    			=			[2, 1, 2, -1]
									SCREAMING_SNAKE_CASE_    			=			[1, 2, 3, 4]







							def _lowercase       (self     ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_    			=			len(self.first_signal     )
									SCREAMING_SNAKE_CASE_    			=			len(self.second_signal     )

									SCREAMING_SNAKE_CASE_    			=			max(SCREAMING_SNAKE_CASE_							,							SCREAMING_SNAKE_CASE_     )

									# create a zero matrix of max_length x max_length
									SCREAMING_SNAKE_CASE_    			=			[[0] * max_length for i in range(SCREAMING_SNAKE_CASE_     )]

									# fills the smaller signal with zeros to make both signals of same length
									if length_first_signal < length_second_signal:
											self.first_signal += [0] * (max_length - length_first_signal)
									elif length_first_signal > length_second_signal:
											self.second_signal += [0] * (max_length - length_second_signal)
									for i in range(SCREAMING_SNAKE_CASE_     ):
											SCREAMING_SNAKE_CASE_    			=			deque(self.second_signal     )
											rotated_signal.rotate(SCREAMING_SNAKE_CASE_     )
											for j, item in enumerate(SCREAMING_SNAKE_CASE_     ):
													matrix[i][j] += item

        # multiply the matrix with the first signal
									SCREAMING_SNAKE_CASE_    			=			np.matmul(np.transpose(SCREAMING_SNAKE_CASE_     )							,							np.transpose(self.first_signal     )     )

									# rounding-off to two decimal places
									return [round(SCREAMING_SNAKE_CASE_							,							2     ) for i in final_signal]


if __name__ == "__main__":
						doctest.testmod()