




"""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_ (				lowerCamelCase_ ):







   """simple docstring"""




   A_										=					1
   A_										=					2
   A_										=					3







   def __repr__(		self)							->      Any:
       return F'{self.__class__.__name__}.{self.name}'





def     __snake_case   (							_lowercase     :   tuple[int, int] ,_lowercase     :   int ,_lowercase     :   int						):


    """simple docstring"""







    UpperCamelCase										=  point
    return degrees(atana(y - miny ,x - minx						)						)





def     __snake_case   (							_lowercase     :   tuple[int, int] ,_lowercase     :   tuple[int, int] ,_lowercase     :   tuple[int, int]						):


    """simple docstring"""







    UpperCamelCase										=  starting
    UpperCamelCase										=  via
    UpperCamelCase										=  target
    UpperCamelCase										=  degrees(atana(ya - ya ,xa - xa						)						)
    via_angle %= 360
    UpperCamelCase										=  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     __snake_case   (							_lowercase     :   list[tuple[int, int]]						):


    """simple docstring"""







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

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

    UpperCamelCase										=  sorted(UpperCamelCase__ ,key=lambda _lowercase						: angle_comparer(UpperCamelCase__ ,UpperCamelCase__ ,UpperCamelCase__						)						)
    # 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)						)

    UpperCamelCase										=  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.
    UpperCamelCase										=  Direction.left

    for i in range(3 ,len(UpperCamelCase__						)						):
        while True:
            UpperCamelCase										=  stack[-2]
            UpperCamelCase										=  stack[-1]
            UpperCamelCase										=  sorted_points[i]
            UpperCamelCase										=  check_direction(UpperCamelCase__ ,UpperCamelCase__ ,UpperCamelCase__						)

            if next_direction == Direction.left:
                UpperCamelCase										=  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(UpperCamelCase__						)





"""simple docstring"""







from math import pi





def     __snake_case   (							_lowercase						):


    """simple docstring"""







    return degree / (180 / pi)


if __name__ == "__main__":
  from doctest import testmod

  testmod()