





"""simple docstring"""


import math
import sys




def 					lowercase__    (					lowercase_			)					->		int:




      """simple docstring"""

      if number != int(__A			):
            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
      _UpperCamelCase      :	List[str]						=       [-1] * (number + 1)
      _UpperCamelCase      :	Dict						=       0
      for i in range(1		,number + 1			):
            _UpperCamelCase      :	Union[str, Any]						=       sys.maxsize
            _UpperCamelCase      :	List[Any]						=       int(math.sqrt(__A			)			)
            for j in range(1		,root + 1			):
                  _UpperCamelCase      :	Optional[Any]						=       1 + answers[i - (j**2)]
                  _UpperCamelCase      :	List[str]						=       min(__A		,__A			)
            _UpperCamelCase      :	Dict						=       answer
      return answers[number]


if __name__ == "__main__":
  import doctest

  doctest.testmod()







"""simple docstring"""


from __future__ import annotations

import string
from itertools import cycle, product
from pathlib import Path

lowerCamelCase__				  =   (
    string.ascii_letters + string.digits + string.punctuation + string.whitespace
)
lowerCamelCase__				  =   [ord(letter) for letter in string.ascii_lowercase]
lowerCamelCase__				  =   {ord(char) for char in VALID_CHARS}

lowerCamelCase__				  =   ["the", "be", "to", "of", "and", "in", "that", "have"]




def 					lowercase__    (					lowercase_		,lowercase_			)					->		str | None:




      """simple docstring"""

      _UpperCamelCase      :	str						=       ""
      _UpperCamelCase      :	int
      _UpperCamelCase      :	int
      _UpperCamelCase      :	int

      for keychar, cipherchar in zip(cycle(lowercase_			)		,lowercase_			):
            _UpperCamelCase      :	Dict						=       cipherchar ^ keychar
            if decodedchar not in VALID_INTS:
                  return None
            decoded += chr(lowercase_			)

      return decoded




def 					lowercase__    (					lowercase_			)					->		list[str]:




      """simple docstring"""

      _UpperCamelCase      :	list[str]						=       []
      for key in product(lowercase_		,repeat=3			):
            _UpperCamelCase      :	int						=       try_key(lowercase_		,lowercase_			)
            if encoded is not None:
                  possibles.append(lowercase_			)
      return possibles




def 					lowercase__    (					lowercase_		,lowercase_			)					->		list[str]:




      """simple docstring"""

      return [possible for possible in possibles if common_word in possible.lower()]




def 					lowercase__    (					lowercase_ = "p059_cipher.txt"			)					->		int:




      """simple docstring"""

      _UpperCamelCase      :	list[int]
      _UpperCamelCase      :	list[str]
      _UpperCamelCase      :	str
      _UpperCamelCase      :	str
      _UpperCamelCase      :	str						=       Path(lowercase_			).parent.joinpath(lowercase_			).read_text(encoding="utf-8"			)

      _UpperCamelCase      :	Optional[Any]						=       [int(lowercase_			) for number in data.strip().split(","			)]

      _UpperCamelCase      :	List[str]						=       filter_valid_chars(lowercase_			)
      for common_word in COMMON_WORDS:
            _UpperCamelCase      :	Union[str, Any]						=       filter_common_word(lowercase_		,lowercase_			)
            if len(lowercase_			) == 1:
                  break

      _UpperCamelCase      :	Union[str, Any]						=       possibles[0]
      return sum(ord(lowercase_			) for char in decoded_text			)


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