"""simple docstring"""



from __future__ import annotations

from enum import Enum, unique
from typing import TypeVar

# Create a generic variable that can be 'Enum', or any subclass.
_UpperCamelCase         =		TypeVar("T", bound="Enum")
@unique
class 	__UpperCAmelCase						(__A    ):







   '''simple docstring'''
   _UpperCamelCase     :	Optional[int]				    =							80
   _UpperCamelCase     :	Union[str, Any]				    =							70
   _UpperCamelCase     :	Tuple				    =							60
   _UpperCamelCase     :	Tuple				    =							50
   _UpperCamelCase     :	Dict				    =							40
   _UpperCamelCase     :	List[Any]				    =							30
   _UpperCamelCase     :	Any				    =							20
   _UpperCamelCase     :	List[str]				    =							10





@unique
class 	__UpperCAmelCase						(__A    ):







   '''simple docstring'''
   _UpperCamelCase     :	Optional[int]				    =							24
   _UpperCamelCase     :	Any				    =							21
   _UpperCamelCase     :	str				    =							18
   _UpperCamelCase     :	Optional[Any]				    =							15
   _UpperCamelCase     :	Optional[Any]				    =							12
   _UpperCamelCase     :	Optional[int]				    =							9
   _UpperCamelCase     :	Optional[Any]				    =							6
   _UpperCamelCase     :	Optional[Any]				    =							3
   _UpperCamelCase     :	Optional[int]				    =							2
   _UpperCamelCase     :	Any				    =							1
   _UpperCamelCase     :	Tuple				    =							-1
   _UpperCamelCase     :	Union[str, Any]				    =							-2
   _UpperCamelCase     :	List[Any]				    =							-3
   _UpperCamelCase     :	Union[str, Any]				    =							-6
   _UpperCamelCase     :	List[str]				    =							-9
   _UpperCamelCase     :	Tuple				    =							-12
   _UpperCamelCase     :	List[Any]				    =							-15
   _UpperCamelCase     :	List[Any]				    =							-18
   _UpperCamelCase     :	List[str]				    =							-21
   _UpperCamelCase     :	Union[str, Any]				    =							-24





   @classmethod
   def 		lowerCamelCase				( cls       ):







          '''simple docstring'''


          return {unit.name: unit.value for unit in cls if unit.value > 0}





   @classmethod
   def 		lowerCamelCase				( cls       ):







          '''simple docstring'''


          return {unit.name: unit.value for unit in cls if unit.value < 0}





def    _A(		lowerCAmelCase       ):
       A__					:    Dict														= SIUnit.get_positive() if value > 0 else SIUnit.get_negative()
       for name_prefix, value_prefix in prefixes.items():
              A__					:    int														= value / (10**value_prefix)
              if numerical_part > 1:
                     return F'''{numerical_part!s} {name_prefix}'''
       return str(lowerCAmelCase       )

def    _A(		lowerCAmelCase       ):
       for prefix in BinaryUnit:
              A__					:    Optional[int]														= value / (2**prefix.value)
              if numerical_part > 1:
                     return F'''{numerical_part!s} {prefix.name}'''
       return str(lowerCAmelCase       )


if __name__ == "__main__":
    import doctest

    doctest.testmod()






"""simple docstring"""



def    _A(		lowerCAmelCase       ):
							A__					:    str														= len(lowerCAmelCase       )
							A__					:    List[Any]														= [0] * length
							A__					:    Union[str, Any]														= [[False for i in range(lowerCAmelCase       )] for j in range(lowerCAmelCase       )]
							for i, c in enumerate(lowerCAmelCase       ):
														A__					:    Dict														= i
														for j in range(i + 1       ):
																					if c == string[j] and (i - j < 2 or is_palindromic[j + 1][i - 1]):
																												A__					:    List[str]														= True
																												A__					:    Optional[Any]														= min(lowerCAmelCase ,     0 if j == 0 else (cut[j - 1] + 1)       )
														A__					:    Optional[int]														= mincut
							return cut[length - 1]


if __name__ == "__main__":
				_UpperCamelCase         =		input("Enter the string: ").strip()
				_UpperCamelCase         =		find_minimum_partitions(s)
				print(F'Minimum number of partitions required for the \'{s}\' is {ans}')





