



'''simple docstring'''

from __future__ import annotations

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



class 		lowerCamelCase__   (    A  ):




					'''simple docstring'''



					A_         =    1
					A_         =    2
					A_         =    3




					def __repr__(	self					:						str       )	->							Optional[Any]:



						'''simple docstring'''





						return F'''{self.__class__.__name__}.{self.name}'''







def     __UpperCamelCase					(				_lowercase,					_lowercase,					_lowercase       )			->      float:
	_lowercase	,     _lowercase       :							Optional[int]  	=		point
	return degrees(atana(y - miny,					x - minx       )       )







def     __UpperCamelCase					(				_lowercase,					_lowercase,					_lowercase       )			->      Direction:
	_lowercase	,     _lowercase       :							Union[str, Any]  	=		starting
	_lowercase	,     _lowercase       :							Any  	=		via
	_lowercase	,     _lowercase       :							Optional[int]  	=		target
	_lowercase       :							Any  	=		degrees(atana(ya - ya,					xa - xa       )       )
	via_angle %= 360
	_lowercase       :							Union[str, Any]  	=		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					(				_lowercase       )			->      list[tuple[int, int]]:

	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
	_lowercase       :							Union[str, Any]  	=		0
	_lowercase	,     _lowercase       :							str  	=		maxsize, maxsize
	for i, point in enumerate(_lowercase       ):
		_lowercase       :							Optional[int]  	=		point[0]
		_lowercase       :							str  	=		point[1]
		if y < miny:
			_lowercase       :							int  	=		y
			_lowercase       :							Optional[Any]  	=		x
			_lowercase       :							Optional[Any]  	=		i
		if y == miny and x < minx:
			_lowercase       :							int  	=		x
			_lowercase       :							List[str]  	=		i

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

	_lowercase       :							Optional[Any]  	=		sorted(_lowercase,					key=lambda _lowercase       : 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)       )

	_lowercase       :							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.
	_lowercase       :							Optional[Any]  	=		Direction.left

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

			if next_direction == Direction.left:
				_lowercase       :							Union[str, Any]  	=		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       )





'''simple docstring'''

def     __UpperCamelCase					(				_lowercase = 1000       )			->      int:
	_lowercase       :							Dict  	=		0
	_lowercase       :							int  	=		0
	while 1:
		num += 3
		if num >= n:
			break
		total += num
		num += 2
		if num >= n:
			break
		total += num
		num += 1
		if num >= n:
			break
		total += num
		num += 3
		if num >= n:
			break
		total += num
		num += 1
		if num >= n:
			break
		total += num
		num += 2
		if num >= n:
			break
		total += num
		num += 3
		if num >= n:
			break
		total += num
	return total


if __name__ == "__main__":
		print(F'''{solution() = }''')
