

"""simple docstring"""





import itertools




def     _A    (    UpperCamelCase_	:			Dict = 1000000)      ->		Optional[int]:
   '''simple docstring'''


   __lowercase								=		[1]

   for i in itertools.count(len(UpperCAmelCase_)):
      __lowercase								=		0
      for j in itertools.count(1):
         __lowercase								=		-1 if j % 2 == 0 else +1
         __lowercase								=		(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(UpperCAmelCase_)

   return 0


if __name__ == "__main__":
   import doctest

   doctest.testmod()

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










from __future__ import annotations

from typing import Generic, TypeVar

SCREAMING_SNAKE_CASE_    :       List[str]       =							TypeVar('''T''')







class 		__UpperCAmelCase(		lowercase__			):





     """simple docstring"""



     pass







class 		__UpperCAmelCase(		lowercase__			):





     """simple docstring"""



     pass







class 		__UpperCAmelCase(		Generic[T]			):





     """simple docstring"""



     def __init__(   self			:							str    ,					A			:							int = 10     )      ->      str:






         """simple docstring"""
         a__  			=							[]
         a__  			=							limit

     def __bool__(   self			:							Dict     )      ->      bool:






         """simple docstring"""
         return bool(self.stack     )

     def __str__(   self			:							str     )      ->      str:






         """simple docstring"""
         return str(self.stack     )

     def 					__SCREAMING_SNAKE_CASE		(   self			:							List[str]    ,					A			:							T     )      ->      None:






         """simple docstring"""
         if len(self.stack     ) >= self.limit:
             raise StackOverflowError
         self.stack.append(A     )

     def 					__SCREAMING_SNAKE_CASE		(   self			:							Any     )      ->      T:






         """simple docstring"""
         if not self.stack:
             raise StackUnderflowError
         return self.stack.pop()

     def 					__SCREAMING_SNAKE_CASE		(   self			:							Optional[int]     )      ->      T:






         """simple docstring"""
         if not self.stack:
             raise StackUnderflowError
         return self.stack[-1]

     def 					__SCREAMING_SNAKE_CASE		(   self			:							str     )      ->      bool:






         """simple docstring"""
         return not bool(self.stack     )

     def 					__SCREAMING_SNAKE_CASE		(   self			:							Dict     )      ->      bool:






         """simple docstring"""
         return self.size() == self.limit

     def 					__SCREAMING_SNAKE_CASE		(   self			:							int     )      ->      int:






         """simple docstring"""
         return len(self.stack     )






     def __contains__(   self			:							int    ,					A			:							T     )      ->      bool:






         """simple docstring"""
         return item in self.stack






def 							__lowerCAmelCase			():
    a__  			=							Stack(10		)
    assert bool(UpperCAmelCase_		) is False
    assert stack.is_empty() is True
    assert stack.is_full() is False
    assert str(UpperCAmelCase_		) == "[]"

    try:
        a__  			=							stack.pop()
        raise AssertionError  # This should not happen
    except StackUnderflowError:
        assert True  # This should happen

    try:
        a__  			=							stack.peek()
        raise AssertionError  # This should not happen
    except StackUnderflowError:
        assert True  # This should happen

    for i in range(10		):
        assert stack.size() == i
        stack.push(UpperCAmelCase_		)

    assert bool(UpperCAmelCase_		)
    assert not stack.is_empty()
    assert stack.is_full()
    assert str(UpperCAmelCase_		) == str(list(range(10		)		)		)
    assert stack.pop() == 9
    assert stack.peek() == 8

    stack.push(100		)
    assert str(UpperCAmelCase_		) == str([0, 1, 2, 3, 4, 5, 6, 7, 8, 100]		)

    try:
        stack.push(200		)
        raise AssertionError  # This should not happen
    except StackOverflowError:
        assert True  # This should happen

    assert not stack.is_empty()
    assert stack.size() == 10

    assert 5 in stack
    assert 55 not in stack


if __name__ == "__main__":
 test_stack()






