





def 					__lowerCamelCase       (							a_					:		list							)      ->				list:

      if len(a_							) < 2:
            return collection

      def circle_sort_util(a_					:		list			,       a_					:		int			,       a_					:		int							) -> bool:
            __SCREAMING_SNAKE_CASE       :List[Any]		    =  False

            if low == high:
                  return swapped

            __SCREAMING_SNAKE_CASE       :Dict		    =  low
            __SCREAMING_SNAKE_CASE       :List[Any]		    =  high

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

                  left += 1
                  right -= 1

            if left == right and collection[left] > collection[right + 1]:
                  __SCREAMING_SNAKE_CASE       :Any		    =  (
                      collection[right + 1],
                      collection[left],
                  )

                  __SCREAMING_SNAKE_CASE       :Optional[int]		    =  True

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

            return swapped or left_swap or right_swap

      __SCREAMING_SNAKE_CASE       :str		    =  True

      while is_not_sorted is True:
            __SCREAMING_SNAKE_CASE       :Optional[Any]		    =  circle_sort_util(a_			,       0			,       len(a_							) - 1							)

      return collection


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






"""simple docstring"""
import math
import unittest



def 					__lowerCamelCase       (							a_					:		int							)      ->				bool:
      assert isinstance(a_			,       a_							) and (
          number >= 0
      ), "'number' must been an int and positive"

      if 1 < number < 4:
            # 2 and 3 are primes
            return True
      elif number < 2 or number % 2 == 0 or number % 3 == 0:
            # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
            return False

      # All primes number are in format of 6k +/- 1
      for i in range(5			,       int(math.sqrt(a_							) + 1							)			,       6							):
            if number % i == 0 or number % (i + 2) == 0:
                  return False
      return True






class  _SCREAMING_SNAKE_CASE(       unittest.TestCase  ):




       def    _UpperCamelCase					(						self							)      ->				Union[str, Any]:





             """simple docstring"""






             self.assertTrue(is_prime(2							)							)
             self.assertTrue(is_prime(3							)							)
             self.assertTrue(is_prime(5							)							)
             self.assertTrue(is_prime(7							)							)
             self.assertTrue(is_prime(11							)							)
             self.assertTrue(is_prime(13							)							)
             self.assertTrue(is_prime(17							)							)
             self.assertTrue(is_prime(19							)							)
             self.assertTrue(is_prime(23							)							)
             self.assertTrue(is_prime(29							)							)




       def    _UpperCamelCase					(						self							)      ->				Tuple:





             """simple docstring"""






             with self.assertRaises(SCREAMING_SNAKE_CASE__							):
                   is_prime(-19							)
             self.assertFalse(
                 is_prime(0							)		,'''Zero doesn\'t have any positive factors, primes must have exactly two.'''		,)
             self.assertFalse(
                 is_prime(1							)		,'''One only has 1 positive factor, primes must have exactly two.'''		,)
             self.assertFalse(is_prime(2 * 2							)							)
             self.assertFalse(is_prime(2 * 3							)							)
             self.assertFalse(is_prime(3 * 3							)							)
             self.assertFalse(is_prime(3 * 5							)							)
             self.assertFalse(is_prime(3 * 5 * 7							)							)


if __name__ == "__main__":
  unittest.main()