





import math
import sys







def 			A__							(    SCREAMING_SNAKE_CASE__)   ->    Union[str, Any]:
  if number != int(UpperCamelCase__):
    raise ValueError("""the value of input must be a natural number""")
  if number < 0:
    raise ValueError("""the value of input must not be a negative number""")
  if number == 0:
    return 1
  __snake_case:						str   =						[-1] * (number + 1)
  __snake_case:						List[Any]   =						0
  for i in range(1					,					number + 1):
    __snake_case:						List[str]   =						sys.maxsize
    __snake_case:						str   =						int(math.sqrt(UpperCamelCase__))
    for j in range(1					,					root + 1):
      __snake_case:						Union[str, Any]   =						1 + answers[i - (j**2)]
      __snake_case:						Optional[int]   =						min(UpperCamelCase__					,					UpperCamelCase__)
    __snake_case:						List[str]   =						answer
  return answers[number]


if __name__ == "__main__":
      import doctest

      doctest.testmod()














"""simple docstring"""




from collections.abc import Iterable
from typing import Generic, TypeVar

_snake_case          =   TypeVar('_T')






class        UpperCamelCase			(	Generic[_T]      ):


 def __init__(     self		:						Optional[int]							,						UpperCAmelCase__		:						Iterable[_T] | None = None							)					->       None:
   _a  :       list[_T]             =	list(iterable or []							)
   _a  :       list[_T]             =	[]


 def __len__(     self		:						str							)					->       int:
   return len(self._stacka							) + len(self._stacka							)


 def __repr__(     self		:						List[str]							)					->       str:
   return f"""Queue({tuple(self._stacka[::-1] + self._stacka							)})"""


 def _lowercase	(     self		:						Union[str, Any]							,						UpperCAmelCase__		:						_T							)					->       None:
   self._stacka.append(UpperCAmelCase__							)







 def _lowercase	(     self		:						Optional[Any]							)					->       _T:
   _a  :       Any             =	self._stacka.pop
   _a  :       Union[str, Any]             =	self._stacka.append

   if not self._stacka:
     while self._stacka:
       stacka_append(stacka_pop()							)

   if not self._stacka:
     raise IndexError("""Queue is empty"""							)
   return self._stacka.pop()


if __name__ == "__main__":
 from doctest import testmod

 testmod()

