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				(  lowercase__				):






		"""simple docstring"""







		A_    			=   1
		A_    			=   2
		A_    			=   3



		def __repr__(      self     :					str ):






					"""simple docstring"""
					return F'{self.__class__.__name__}.{self.name}'






def  UpperCAmelCase__(    lowerCamelCase_				,						lowerCamelCase_				,						lowerCamelCase_	):



			"""simple docstring"""





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






def  UpperCAmelCase__(    lowerCamelCase_				,						lowerCamelCase_				,						lowerCamelCase_	):



			"""simple docstring"""





			_snake_case							,			_snake_case														=   starting
			_snake_case							,			_snake_case														=   via
			_snake_case							,			_snake_case														=   target
			_snake_case														=   degrees(atana(ya - ya				,						xa - xa	)	)
			via_angle %= 360
			_snake_case														=   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  UpperCAmelCase__(    lowerCamelCase_	):



			"""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
			_snake_case														=   0
			_snake_case							,			_snake_case														=   maxsize, maxsize
			for i, point in enumerate(lowercase_	):
						_snake_case														=   point[0]
						_snake_case														=   point[1]
						if y < miny:
									_snake_case														=   y
									_snake_case														=   x
									_snake_case														=   i
						if y == miny and x < minx:
									_snake_case														=   x
									_snake_case														=   i

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

			_snake_case														=   sorted(lowercase_				,						key=lambda lowerCamelCase_	: 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)	)

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

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

									if next_direction == Direction.left:
												_snake_case														=   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_	)









def 						A_					(						lowercase_	,  lowercase_			)				->List[Any]:







 """simple docstring"""

 SCREAMING_SNAKE_CASE				    =		1
 while b > 0:
  if b & 1:
   res *= a

  a *= a
  b >>= 1

 return res





def 						A_					(						lowercase_	,  lowercase_	,  lowercase_			)				->Any:







 """simple docstring"""

 SCREAMING_SNAKE_CASE				    =		1
 while b > 0:
  if b & 1:
   SCREAMING_SNAKE_CASE				    =		((res % c) * (a % c)) % c

  a *= a
  b >>= 1

 return res




