


'''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    :							Dict):
           return F'{self.__class__.__name__}.{self.name}'






def    lowerCAmelCase__ (       lowerCamelCase  :    tuple[int, int]						,lowerCamelCase  :    int						,lowerCamelCase  :    int     ):
       _A  :			Optional[int]											=      point
       return degrees(atana(y - miny						,x - minx     )     )






def    lowerCAmelCase__ (       lowerCamelCase  :    tuple[int, int]						,lowerCamelCase  :    tuple[int, int]						,lowerCamelCase  :    tuple[int, int]     ):
       _A  :			int											=      starting
       _A  :			Any											=      via
       _A  :			Dict											=      target
       _A  :			Dict											=      degrees(atana(ya - ya						,xa - xa     )     )
       via_angle %= 360
       _A  :			int											=      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    lowerCAmelCase__ (       lowerCamelCase  :    list[tuple[int, int]]     ):

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

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

       _A  :			int											=      sorted(lowerCamelCase						,key=lambda lowerCamelCase     : 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)     )

       _A  :			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.
       _A  :			Any											=      Direction.left

       for i in range(3						,len(lowerCamelCase     )     ):
              while True:
                     _A  :			Tuple											=      stack[-2]
                     _A  :			Dict											=      stack[-1]
                     _A  :			Optional[Any]											=      sorted_points[i]
                     _A  :			Dict											=      check_direction(lowerCamelCase						,lowerCamelCase						,lowerCamelCase     )

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










'''simple docstring'''







import itertools






def    lowerCAmelCase__ (       lowerCamelCase  :    int = 1000000     ):
       _A  :			str											=      [1]

       for i in itertools.count(len(lowerCamelCase     )     ):
              _A  :			Optional[Any]											=      0
              for j in itertools.count(1     ):
                     _A  :			int											=      -1 if j % 2 == 0 else +1
                     _A  :			Optional[Any]											=      (j * j * 3 - j) // 2
                     if index > i:
                            break
                     item += partitions[i - index] * sign
                     item %= number
                     index += j
                     if index > i:
                            break
                     item += partitions[i - index] * sign
                     item %= number

              if item == 0:
                     return i
              partitions.append(lowerCamelCase     )

       return 0


if __name__ == "__main__":
   import doctest

   doctest.testmod()

   print(f"""{solution() = }""")






