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 __UpperCamelCase    (							A__		):
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  					__magic_name__     			=      1
  					__magic_name__     			=      2
  					__magic_name__     			=      3
  
  
  
  
  
  					def __repr__(							self	):
  						return F"{self.__class__.__name__}.{self.name}"
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			):
  	UpperCAmelCase__:  Any		       =   point
  	return degrees(atana(y - miny  ,x - minx			)			)
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE  ,SCREAMING_SNAKE_CASE			):
  	UpperCAmelCase__:  Optional[Any]		       =   starting
  	UpperCAmelCase__:  Tuple		       =   via
  	UpperCAmelCase__:  Optional[Any]		       =   target
  	UpperCAmelCase__:  List[str]		       =   degrees(atana(ya - ya  ,xa - xa			)			)
  	via_angle %= 3_6_0
  	UpperCAmelCase__:  int		       =   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  _A  (			SCREAMING_SNAKE_CASE			):
  
  	if len(__lowerCAmelCase			) <= 2:
  		# There is no convex hull
  		raise ValueError("graham_scan: argument must contain more than 3 points."			)
  	if len(__lowerCAmelCase			) == 3:
  		return points
  	# find the lowest and the most left point
  	UpperCAmelCase__:  Any		       =   0
  	UpperCAmelCase__:  Optional[int]		       =   maxsize, maxsize
  	for i, point in enumerate(__lowerCAmelCase			):
  		UpperCAmelCase__:  List[str]		       =   point[0]
  		UpperCAmelCase__:  Any		       =   point[1]
  		if y < miny:
  			UpperCAmelCase__:  str		       =   y
  			UpperCAmelCase__:  int		       =   x
  			UpperCAmelCase__:  List[str]		       =   i
  		if y == miny and x < minx:
  			UpperCAmelCase__:  Any		       =   x
  			UpperCAmelCase__:  Union[str, Any]		       =   i
  
      # remove the lowest and the most left point from points for preparing for sort
  	points.pop(__lowerCAmelCase			)
  
  	UpperCAmelCase__:  List[Any]		       =   sorted(__lowerCAmelCase  ,key=lambda SCREAMING_SNAKE_CASE			: angle_comparer(__lowerCAmelCase  ,__lowerCAmelCase  ,__lowerCAmelCase			)			)
  	# 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[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.
  	UpperCAmelCase__:  Dict		       =   Direction.left
  
  	for i in range(3  ,len(__lowerCAmelCase			)			):
  		while True:
  			UpperCAmelCase__:  Dict		       =   stack[-2]
  			UpperCAmelCase__:  List[str]		       =   stack[-1]
  			UpperCAmelCase__:  List[str]		       =   sorted_points[i]
  			UpperCAmelCase__:  Optional[int]		       =   check_direction(__lowerCAmelCase  ,__lowerCAmelCase  ,__lowerCAmelCase			)
  
  			if next_direction == Direction.left:
  				UpperCAmelCase__:  Dict		       =   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(__lowerCAmelCase			)
style_context: 
  
  import numpy as np
  
  
  
  def  _A  (			SCREAMING_SNAKE_CASE			):
  	UpperCAmelCase__:  List[Any]		       =   np.exp(SCREAMING_SNAKE_CASE			)
  
  	# Add up the all the exponentials
  	UpperCAmelCase__:  str		       =   np.sum(SCREAMING_SNAKE_CASE			)
  
  	# Divide every exponent by the sum of all exponents
  	UpperCAmelCase__:  Tuple		       =   exponent_vector / sum_of_exponents
  
  	return softmax_vector
  
  
  if __name__ == "__main__":
  					print(softmax((0,)))