code: 
  
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  from __future__ import annotations
  
  from collections import deque
  from enum import Enum
  from math import atana, degrees
  from sys import maxsize
  
  
  
  
  
  
  
  class        __lowerCAmelCase (					UpperCamelCase__):
        _lowercase       :      int        =    1
        _lowercase       :      List[str]        =    2
        _lowercase       :      Union[str, Any]        =    3
  
  
  
  
  
  
  
        def __repr__(					self							)     ->		Union[str, Any]:
  
  
  
          '''simple docstring'''
  
  
  
  
          return F'''{self.__class__.__name__}.{self.name}'''
  def   _A (	SCREAMING_SNAKE_CASE  :     tuple[int, int] , SCREAMING_SNAKE_CASE  :     int , SCREAMING_SNAKE_CASE  :     int		):
  
  
  
  
  
    """simple docstring"""
  
  
  
    a__			:      Dict            =point
    return degrees(atana(y - miny , x - minx		)		)
  def   _A (	SCREAMING_SNAKE_CASE  :     tuple[int, int] , SCREAMING_SNAKE_CASE  :     tuple[int, int] , SCREAMING_SNAKE_CASE  :     tuple[int, int]		):
  
  
  
  
  
    """simple docstring"""
  
  
  
    a__			:      Union[str, Any]            =starting
    a__			:      Optional[int]            =via
    a__			:      Any            =target
    a__			:      str            =degrees(atana(ya - ya , xa - xa		)		)
    via_angle %= 360
    a__			:      List[str]            =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 (	SCREAMING_SNAKE_CASE  :     list[tuple[int, int]]		):
  
  
  
  
  
    """simple docstring"""
  
  
  
    if len(SCREAMING_SNAKE_CASE		) <= 2:
      # There is no convex hull
      raise ValueError("graham_scan: argument must contain more than 3 points."		)
    if len(SCREAMING_SNAKE_CASE		) == 3:
      return points
    # find the lowest and the most left point
    a__			:      Union[str, Any]            =0
    a__			:      List[Any]            =maxsize, maxsize
    for i, point in enumerate(SCREAMING_SNAKE_CASE		):
      a__			:      List[Any]            =point[0]
      a__			:      str            =point[1]
      if y < miny:
        a__			:      Tuple            =y
        a__			:      str            =x
        a__			:      str            =i
      if y == miny and x < minx:
        a__			:      List[Any]            =x
        a__			:      Optional[int]            =i
  
      # remove the lowest and the most left point from points for preparing for sort
    points.pop(SCREAMING_SNAKE_CASE		)
  
    a__			:      Optional[int]            =sorted(SCREAMING_SNAKE_CASE , key=lambda SCREAMING_SNAKE_CASE		: angle_comparer(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE		)		)
    # 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)		)
  
    a__			:      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.
    a__			:      Optional[int]            =Direction.left
  
    for i in range(3 , len(SCREAMING_SNAKE_CASE		)		):
      while True:
        a__			:      Optional[Any]            =stack[-2]
        a__			:      str            =stack[-1]
        a__			:      str            =sorted_points[i]
        a__			:      Optional[Any]            =check_direction(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE		)
  
        if next_direction == Direction.left:
          a__			:      Tuple            =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(SCREAMING_SNAKE_CASE		)
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  def   _A (	SCREAMING_SNAKE_CASE  :     int		):
  
  
  
  
  
    """simple docstring"""
  
  
  
    if not isinstance(SCREAMING_SNAKE_CASE , SCREAMING_SNAKE_CASE		) or number < 0:
      raise ValueError("Input must be a non-negative integer"		)
  
    a__			:      List[str]            =number & ~(number - 1)
    a__			:      Optional[int]            =0
    while intermediate:
      intermediate >>= 1
      index += 1
    return index - 1
  
  
  if __name__ == "__main__":
       import doctest
  
       doctest.testmod(verbose=True)
  
  
  
  
  
  
  