





def    __UpperCAmelCase(      lowercase_      ):

       if len(lowercase_      ) < 2:
              return collection

       def circle_sort_util(lowercase_ ,    lowercase_ ,    lowercase_      ) -> bool:
              _lowerCamelCase							:     Dict	=		False

              if low == high:
                     return swapped

              _lowerCamelCase							:     List[Any]	=		low
              _lowerCamelCase							:     List[Any]	=		high

              while left < right:
                     if collection[left] > collection[right]:
                            _lowerCamelCase,  _lowerCamelCase							:     List[str]	=		(
                                collection[right],
                                collection[left],
                            )
                            _lowerCamelCase							:     str	=		True

                     left += 1
                     right -= 1

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

                     _lowerCamelCase							:     str	=		True

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

              return swapped or left_swap or right_swap

       _lowerCamelCase							:     Tuple	=		True

       while is_not_sorted is True:
              _lowerCamelCase							:     str	=		circle_sort_util(lowercase_ ,    0 ,    len(lowercase_      ) - 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))








_lowerCamelCase			       =      [4, 1, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
_lowerCamelCase			       =      [3, 7, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
_lowerCamelCase			       =      {
    0: 'Sunday',
    1: 'Monday',
    2: 'Tuesday',
    3: 'Wednesday',
    4: 'Thursday',
    5: 'Friday',
    6: 'Saturday',
}




def    __UpperCAmelCase(      lowercase_ ,    lowercase_ ,    lowercase_      ):
       assert len(str(lowercase_      )      ) > 2, "year should be in YYYY format"
       assert 1 <= month <= 12, "month should be between 1 to 12"
       assert 1 <= day <= 31, "day should be between 1 to 31"

       # Doomsday algorithm:
       _lowerCamelCase							:     List[Any]	=		year // 1_00
       _lowerCamelCase							:     Dict	=		(5 * (century % 4) + 2) % 7
       _lowerCamelCase							:     Tuple	=		year % 1_00
       _lowerCamelCase							:     int	=		centurian % 12
       _lowerCamelCase							:     List[Any]	=		(
           (centurian // 12) + centurian_m + (centurian_m // 4) + century_anchor
       ) % 7
       _lowerCamelCase							:     List[Any]	=		(
           DOOMSDAY_NOT_LEAP[month - 1]
           if (year % 4 != 0) or (centurian == 0 and (year % 4_00) == 0)
           else DOOMSDAY_LEAP[month - 1]
       )
       _lowerCamelCase							:     Any	=		(dooms_day + day - day_anchor) % 7
       return WEEK_DAY_NAMES[week_day]


if __name__ == "__main__":
       import doctest

       doctest.testmod()

