

'''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			)


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,)))