


'''simple docstring'''




def 							a_       (						lowercase    )			->list:






				'''simple docstring'''

				__lowerCamelCase		:      Optional[int]											=					len(lowercase    )
				for cycle_start in range(0							,						array_len - 1    ):
								__lowerCamelCase		:      str											=					array[cycle_start]

								__lowerCamelCase		:      str											=					cycle_start
								for i in range(cycle_start + 1							,						lowercase    ):
												if array[i] < item:
																pos += 1

								if pos == cycle_start:
												continue

								while item == array[pos]:
												pos += 1

								__lowerCamelCase		:      Optional[Any]											=					item, array[pos]
								while pos != cycle_start:
												__lowerCamelCase		:      Tuple											=					cycle_start
												for i in range(cycle_start + 1							,						lowercase    ):
																if array[i] < item:
																				pos += 1

												while item == array[pos]:
																pos += 1

												__lowerCamelCase		:      Optional[int]											=					item, array[pos]

				return array


if __name__ == "__main__":
				assert cycle_sort([4, 5, 3, 2, 1]) == [1, 2, 3, 4, 5]
				assert cycle_sort([0, 1, -10, 15, 2, -2]) == [-10, -2, 0, 1, 2, 15]









'''simple docstring'''




from __future__ import annotations

from collections import deque
from enum import Enum
from math import atana, degrees
from sys import maxsize





class _snake_case   ( a__   ):
							"""simple docstring"""





							__a												=     1
							__a												=     2
							__a												=     3







							def __repr__(   self	)     ->Tuple:



											"""simple docstring"""







											return f'{self.__class__.__name__}.{self.name}'





def 							a_       (						lowercase							,						lowercase							,						lowercase    )			->float:






				'''simple docstring'''

				__lowerCamelCase						,					__lowerCamelCase		:      str											=					point
				return degrees(atana(y - miny							,						x - minx    )    )





def 							a_       (						lowercase							,						lowercase							,						lowercase    )			->Direction:






				'''simple docstring'''

				__lowerCamelCase						,					__lowerCamelCase		:      List[str]											=					starting
				__lowerCamelCase						,					__lowerCamelCase		:      Any											=					via
				__lowerCamelCase						,					__lowerCamelCase		:      str											=					target
				__lowerCamelCase		:      str											=					degrees(atana(ya - ya							,						xa - xa    )    )
				via_angle %= 360
				__lowerCamelCase		:      List[Any]											=					degrees(atana(ya - ya							,						xa - xa    )    )
				target_angle %= 360
				# t-
				#  \ \
				#   \ v
				#    \|
				#     s
				# via_angle is always lower than target_angle, if direction is left.
				# If they are same, it means they are on a same line of convex hull.
				if target_angle > via_angle:
								return Direction.left
				elif target_angle == via_angle:
								return Direction.straight
				else:
								return Direction.right





def 							a_       (						lowercase    )			->list[tuple[int, int]]:






				'''simple docstring'''

				if len(lowercase    ) <= 2:
								# There is no convex hull
								raise ValueError("graham_scan: argument must contain more than 3 points."    )
				if len(lowercase    ) == 3:
								return points
				# find the lowest and the most left point
				__lowerCamelCase		:      Optional[Any]											=					0
				__lowerCamelCase						,					__lowerCamelCase		:      List[Any]											=					maxsize, maxsize
				for i, point in enumerate(lowercase    ):
								__lowerCamelCase		:      Dict											=					point[0]
								__lowerCamelCase		:      Optional[int]											=					point[1]
								if y < miny:
												__lowerCamelCase		:      Dict											=					y
												__lowerCamelCase		:      int											=					x
												__lowerCamelCase		:      List[Any]											=					i
								if y == miny and x < minx:
												__lowerCamelCase		:      Optional[int]											=					x
												__lowerCamelCase		:      Any											=					i

    # remove the lowest and the most left point from points for preparing for sort
				points.pop(lowercase    )

				__lowerCamelCase		:      Optional[Any]											=					sorted(lowercase							,						key=lambda lowercase    : angle_comparer(lowercase							,						lowercase							,						lowercase    )    )
				# This insert actually costs complexity,
				# and you should instead add (minx, miny) into stack later.
				# I'm using insert just for easy understanding.
				sorted_points.insert(0							,						(minx, miny)    )

				__lowerCamelCase		:      deque[tuple[int, int]]											=					deque()
				stack.append(sorted_points[0]    )
				stack.append(sorted_points[1]    )
				stack.append(sorted_points[2]    )
				# In any ways, the first 3 points line are towards left.
				# Because we sort them the angle from minx, miny.
				__lowerCamelCase		:      str											=					Direction.left

				for i in range(3							,						len(lowercase    )    ):
								while True:
												__lowerCamelCase		:      List[Any]											=					stack[-2]
												__lowerCamelCase		:      str											=					stack[-1]
												__lowerCamelCase		:      int											=					sorted_points[i]
												__lowerCamelCase		:      List[Any]											=					check_direction(lowercase							,						lowercase							,						lowercase    )

												if next_direction == Direction.left:
																__lowerCamelCase		:      Optional[int]											=					Direction.left
																break
												if next_direction == Direction.straight:
																if current_direction == Direction.left:
																				# We keep current_direction as left.
																				# Because if the straight line keeps as straight,
																				# we want to know if this straight line is towards left.
																				break
																elif current_direction == Direction.right:
																				# If the straight line is towards right,
																				# every previous points on those straigh line is not convex hull.
																				stack.pop()
												if next_direction == Direction.right:
																stack.pop()
								stack.append(sorted_points[i]    )
				return list(lowercase    )





