





def lowerCamelCase__   (							snake_case_     :  list	)				->    list:

   if len(snake_case_	) < 2:
      return collection

   def circle_sort_util(snake_case_     :  list	,				snake_case_     :  int	,				snake_case_     :  int	) -> bool:
      __snake_case								=       False

      if low == high:
         return swapped

      __snake_case								=       low
      __snake_case								=       high

      while left < right:
         if collection[left] > collection[right]:
            __snake_case	,     __snake_case								=       (
                collection[right],
                collection[left],
            )
            __snake_case								=       True

         left += 1
         right -= 1

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

         __snake_case								=       True

      __snake_case								=       low + int((high - low) / 2	)
      __snake_case								=       circle_sort_util(snake_case_	,				snake_case_	,				snake_case_	)
      __snake_case								=       circle_sort_util(snake_case_	,				mid + 1	,				snake_case_	)

      return swapped or left_swap or right_swap

   __snake_case								=       True

   while is_not_sorted is True:
      __snake_case								=       circle_sort_util(snake_case_	,				0	,				len(snake_case_	) - 1	)

   return collection


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








class 		SCREAMING_SNAKE_CASE__    :


      def __init__(self	:				str    ,      a__	:				list				):





         """simple docstring"""



         __snake_case								=       set_counts
         __snake_case								=       max(a__				)
         __snake_case								=       len(a__				)
         __snake_case								=       [1] * num_sets
         __snake_case								=       list(range(a__				)				)


      def        a			(self	:				str    ,      a__	:				int    ,      a__	:				int				):





         """simple docstring"""



         __snake_case								=       self.get_parent(a__				)
         __snake_case								=       self.get_parent(a__				)

         if src_parent == dst_parent:
            return False

         if self.ranks[dst_parent] >= self.ranks[src_parent]:
            self.set_counts[dst_parent] += self.set_counts[src_parent]
            __snake_case								=       0
            __snake_case								=       dst_parent
            if self.ranks[dst_parent] == self.ranks[src_parent]:
               self.ranks[dst_parent] += 1
            __snake_case								=       self.set_counts[dst_parent]
         else:
            self.set_counts[src_parent] += self.set_counts[dst_parent]
            __snake_case								=       0
            __snake_case								=       src_parent
            __snake_case								=       self.set_counts[src_parent]

         __snake_case								=       max(self.max_set    ,      a__				)
         return True


      def        a			(self	:				Union[str, Any]    ,      a__	:				int				):





         """simple docstring"""



         if self.parents[disj_set] == disj_set:
            return disj_set
         __snake_case								=       self.get_parent(self.parents[disj_set]				)
         return self.parents[disj_set]

