

from math import floor, sqrt

def 			__snake_case	(   __UpperCamelCase  :   int						):



      """simple docstring"""

      A_	     =							0.0
      A_	     =							1.0
      A_	     =							int(sqrt(__UpperCamelCase						)						)
      A_	     =							root
      A_	     =							0
      while integer_part != 2 * root:
            A_	     =							denominator * integer_part - numerator
            A_	     =							(n - numerator**2) / denominator
            A_	     =							int((root + numerator) / denominator						)
            period += 1
      return period

def 			__snake_case	(   __UpperCamelCase  :   int = 1_0000						):



      """simple docstring"""

      A_	     =							0
      for i in range(2							,n + 1						):
            A_	     =							sqrt(__UpperCamelCase						)
            if sr - floor(__UpperCamelCase						) != 0 and continuous_fraction_period(__UpperCamelCase						) % 2 == 1:
                  count_odd_periods += 1
      return count_odd_periods


if __name__ == "__main__":
      print(F"{solution(int(input().strip()))}")


def 			__snake_case	(   __UpperCamelCase  :   str						):



      """simple docstring"""

      A_	     =							len(__UpperCamelCase						)
      A_	     =							[0] * length
      A_	     =							[[False for i in range(__UpperCamelCase						)] for j in range(__UpperCamelCase						)]
      for i, c in enumerate(__UpperCamelCase						):
            A_	     =							i
            for j in range(i + 1						):
                  if c == string[j] and (i - j < 2 or is_palindromic[j + 1][i - 1]):
                        A_	     =							True
                        A_	     =							min(__UpperCamelCase							,0 if j == 0 else (cut[j - 1] + 1)						)
            A_	     =							mincut
      return cut[length - 1]


if __name__ == "__main__":
      __a						:Union[str, Any]            = input('Enter the string: ').strip()
      __a						:Tuple            = find_minimum_partitions(s)
      print(F"Minimum number of partitions required for the '{s}' is {ans}")