



from __future__ import annotations

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



class 	__lowerCAmelCase       (		lowerCAmelCase__				):
	lowerCAmelCase__       =					1
	lowerCAmelCase__       =					2
	lowerCAmelCase__       =					3




	def __repr__(  self			):



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





def 						a__     (						_UpperCamelCase     :	tuple[int, int]	,_UpperCamelCase     :	int	,_UpperCamelCase     :	int							):
			__lowerCamelCase							,__lowerCamelCase  							=      point
			return degrees(atana(y - miny	,x - minx							)							)





def 						a__     (						_UpperCamelCase     :	tuple[int, int]	,_UpperCamelCase     :	tuple[int, int]	,_UpperCamelCase     :	tuple[int, int]							):
			__lowerCamelCase							,__lowerCamelCase  							=      starting
			__lowerCamelCase							,__lowerCamelCase  							=      via
			__lowerCamelCase							,__lowerCamelCase  							=      target
			__lowerCamelCase  							=      degrees(atana(ya - ya	,xa - xa							)							)
			via_angle %= 3_60
			__lowerCamelCase  							=      degrees(atana(ya - ya	,xa - xa							)							)
			target_angle %= 3_60
			# 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__     (						_UpperCamelCase     :	list[tuple[int, int]]							):

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

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

			__lowerCamelCase  							=      sorted(_UpperCamelCase	,key=lambda _UpperCamelCase							: 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)							)

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

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

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











def 						a__     (						_UpperCamelCase     :	int							):
   if not isinstance(_UpperCamelCase	,_UpperCamelCase							):
      __lowerCamelCase  							=      (
          '''operation can not be conducted on a object of type '''
          F"""{type(_UpperCamelCase							).__name__}"""
      )
      raise TypeError(_UpperCamelCase							)
   __lowerCamelCase  							=      ''''''
   for _ in range(0	,32							):
      bit_string += str(number % 2							)
      __lowerCamelCase  							=      number >> 1
   return bit_string





def 						a__     (						_UpperCamelCase     :	int							):
   if number < 0:
      raise ValueError('''the value of input must be positive'''							)
   elif isinstance(_UpperCamelCase	,_UpperCamelCase							):
      raise TypeError('''Input value must be a \'int\' type'''							)
   elif isinstance(_UpperCamelCase	,_UpperCamelCase							):
      raise TypeError('''\'<\' not supported between instances of \'str\' and \'int\''''							)
   __lowerCamelCase  							=      0
   # iterator over [1 to 32],since we are dealing with 32 bit integer
   for _ in range(1	,33							):
      # left shift the bits by unity
      __lowerCamelCase  							=      result << 1
      # get the end bit
      __lowerCamelCase  							=      number % 2
      # right shift the bits by unity
      __lowerCamelCase  							=      number >> 1
      # add that bit to our ans
      __lowerCamelCase  							=      result | end_bit
   return get_reverse_bit_string(_UpperCamelCase							)


if __name__ == "__main__":
  import doctest

  doctest.testmod()






