"""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		(_UpperCAmelCase						):



    """simple docstring"""

    _UpperCAmelCase			:Optional[int]							=				1
    _UpperCAmelCase			:int							=				2
    _UpperCAmelCase			:List[Any]							=				3






    def __repr__(     self							):
       return F"""{self.__class__.__name__}.{self.name}"""



def SCREAMING_SNAKE_CASE__    (     __UpperCAmelCase ,					__UpperCAmelCase ,					__UpperCAmelCase				)						->						float:
   lowercase__,				lowercase__:     Any      =   point
   return degrees(atana(y - miny ,					x - minx				)				)



def SCREAMING_SNAKE_CASE__    (     __UpperCAmelCase ,					__UpperCAmelCase ,					__UpperCAmelCase				)						->						Direction:
   lowercase__,				lowercase__:     Dict      =   starting
   lowercase__,				lowercase__:     List[str]      =   via
   lowercase__,				lowercase__:     Tuple      =   target
   lowercase__:     List[str]      =   degrees(atana(ya - ya ,					xa - xa				)				)
   via_angle %= 3_6_0
   lowercase__:     Any      =   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 SCREAMING_SNAKE_CASE__    (     __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
   lowercase__:     List[str]      =   0
   lowercase__,				lowercase__:     List[str]      =   maxsize, maxsize
   for i, point in enumerate(__UpperCAmelCase				):
      lowercase__:     Optional[Any]      =   point[0]
      lowercase__:     Dict      =   point[1]
      if y < miny:
         lowercase__:     Union[str, Any]      =   y
         lowercase__:     Tuple      =   x
         lowercase__:     List[Any]      =   i
      if y == miny and x < minx:
         lowercase__:     int      =   x
         lowercase__:     str      =   i

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

   lowercase__:     Optional[int]      =   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)				)

   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(__UpperCAmelCase				)				):
      while True:
         lowercase__:     Dict      =   stack[-2]
         lowercase__:     Optional[int]      =   stack[-1]
         lowercase__:     Optional[int]      =   sorted_points[i]
         lowercase__:     Optional[Any]      =   check_direction(__UpperCAmelCase ,					__UpperCAmelCase ,					__UpperCAmelCase				)

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

"""simple docstring"""






def SCREAMING_SNAKE_CASE__    (     __UpperCAmelCase = 1_0_0_0				)						->						int:
   lowercase__:     Union[str, Any]      =   0
   lowercase__:     Any      =   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() = }''')
