from __future__ import annotations

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






class 							_SCREAMING_SNAKE_CASE(   UpperCamelCase__	):
   UpperCamelCase_				:						List[str] 			=   1
   UpperCamelCase_				:						Union[str, Any] 			=   2
   UpperCamelCase_				:						Optional[Any] 			=   3
   def __repr__(    self    )	->Optional[Any]:
        return F"""{self.__class__.__name__}.{self.name}"""







def 	UpperCAmelCase       (		lowerCAmelCase_						,      lowerCAmelCase_						,      lowerCAmelCase_       )	->	float:
     a  :    List[Any]				=						point
     return degrees(atana(y - miny						,      x - minx       )       )







def 	UpperCAmelCase       (		lowerCAmelCase_						,      lowerCAmelCase_						,      lowerCAmelCase_       )	->	Direction:
     a  :    Optional[int]				=						starting
     a  :    List[Any]				=						via
     a  :    List[str]				=						target
     a  :    Dict				=						degrees(atana(ya - ya						,      xa - xa       )       )
     via_angle %= 3_6_0
     a  :    Any				=						degrees(atana(ya - ya						,      xa - xa       )       )
     target_angle %= 3_6_0
     # 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 	UpperCAmelCase       (		lowerCAmelCase_       )	->	list[tuple[int, int]]:





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

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

     a  :    int				=						sorted(__a						,      key=lambda lowerCAmelCase_       : angle_comparer(__a						,      __a						,      __a       )       )
     # 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  :    List[Any]				=						Direction.left

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

               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(__a       )
def 	UpperCAmelCase       (		lowerCAmelCase_       )	->	int:
     return 1 if input_a == 0 else 0







def 	UpperCAmelCase       (		)	->	None:
     assert not_gate(0       ) == 1
     assert not_gate(1       ) == 0


if __name__ == "__main__":
  print(not_gate(0))
  print(not_gate(1))