




import unittest
from dataclasses import dataclass
from typing import Optional

from transformers.utils import ModelOutput




@dataclass
class       UpperCAmelCase_   ( A							):




							'''simple docstring'''



							a__    	=  42
							a__    	=  None
							a__    	=  None





class       UpperCAmelCase_   ( unittest.TestCase							):




							'''simple docstring'''



							def  _UpperCAmelCase  (       self							:						Optional[Any]      )      ->       Union[str, Any]:
										SCREAMING_SNAKE_CASE     =       ModelOutputTest(a=30      )
										self.assertEqual(x.a							,  30      )
										self.assertIsNone(x.b      )
										self.assertIsNone(x.c      )
										with self.assertRaises(a      ):
													SCREAMING_SNAKE_CASE     =       x.d





							def  _UpperCAmelCase  (       self							:						List[str]      )      ->       Any:
										SCREAMING_SNAKE_CASE     =       ModelOutputTest(a=30							,  b=10      )
										self.assertEqual(x[0]							,  30      )
										self.assertEqual(x[1]							,  10      )
										self.assertEqual(x[:2]							,  (30, 10)      )
										self.assertEqual(x[:]							,  (30, 10)      )

										SCREAMING_SNAKE_CASE     =       ModelOutputTest(a=30							,  c=10      )
										self.assertEqual(x[0]							,  30      )
										self.assertEqual(x[1]							,  10      )
										self.assertEqual(x[:2]							,  (30, 10)      )
										self.assertEqual(x[:]							,  (30, 10)      )





							def  _UpperCAmelCase  (       self							:						Tuple      )      ->       str:
										SCREAMING_SNAKE_CASE     =       ModelOutputTest(a=30							,  b=10      )
										self.assertEqual(x["""a"""]							,  30      )
										self.assertEqual(x["""b"""]							,  10      )
										with self.assertRaises(a      ):
													SCREAMING_SNAKE_CASE     =       x["""c"""]

										SCREAMING_SNAKE_CASE     =       ModelOutputTest(a=30							,  c=10      )
										self.assertEqual(x["""a"""]							,  30      )
										self.assertEqual(x["""c"""]							,  10      )
										with self.assertRaises(a      ):
													SCREAMING_SNAKE_CASE     =       x["""b"""]





							def  _UpperCAmelCase  (       self							:						str      )      ->       Any:
										SCREAMING_SNAKE_CASE     =       ModelOutputTest(a=30      )
										self.assertEqual(list(x.keys()      )							,  ["""a"""]      )
										self.assertEqual(list(x.values()      )							,  [30]      )
										self.assertEqual(list(x.items()      )							,  [("""a""", 30)]      )
										self.assertEqual(list(a      )							,  ["""a"""]      )

										SCREAMING_SNAKE_CASE     =       ModelOutputTest(a=30							,  b=10      )
										self.assertEqual(list(x.keys()      )							,  ["""a""", """b"""]      )
										self.assertEqual(list(x.values()      )							,  [30, 10]      )
										self.assertEqual(list(x.items()      )							,  [("""a""", 30), ("""b""", 10)]      )
										self.assertEqual(list(a      )							,  ["""a""", """b"""]      )

										SCREAMING_SNAKE_CASE     =       ModelOutputTest(a=30							,  c=10      )
										self.assertEqual(list(x.keys()      )							,  ["""a""", """c"""]      )
										self.assertEqual(list(x.values()      )							,  [30, 10]      )
										self.assertEqual(list(x.items()      )							,  [("""a""", 30), ("""c""", 10)]      )
										self.assertEqual(list(a      )							,  ["""a""", """c"""]      )

										with self.assertRaises(a      ):
													SCREAMING_SNAKE_CASE     =       x.update({"""d""": 20}      )
										with self.assertRaises(a      ):
													del x["a"]
										with self.assertRaises(a      ):
													SCREAMING_SNAKE_CASE     =       x.pop("""a"""      )
										with self.assertRaises(a      ):
													SCREAMING_SNAKE_CASE     =       x.setdefault("""d"""							,  32      )





							def  _UpperCAmelCase  (       self							:						Dict      )      ->       Union[str, Any]:
										SCREAMING_SNAKE_CASE     =       ModelOutputTest(a=30      )
										SCREAMING_SNAKE_CASE     =       10
										self.assertEqual(x.a							,  10      )
										self.assertEqual(x["""a"""]							,  10      )





							def  _UpperCAmelCase  (       self							:						List[str]      )      ->       Any:
										SCREAMING_SNAKE_CASE     =       ModelOutputTest(a=30      )
										SCREAMING_SNAKE_CASE     =       10
										self.assertEqual(x.a							,  10      )
										self.assertEqual(x["""a"""]							,  10      )





							def  _UpperCAmelCase  (       self							:						Dict      )      ->       Any:
										SCREAMING_SNAKE_CASE     =       ModelOutputTest({"""a""": 30, """b""": 10}      )
										self.assertEqual(list(x.keys()      )							,  ["""a""", """b"""]      )
										self.assertEqual(x.a							,  30      )
										self.assertEqual(x.b							,  10      )







							def  _UpperCAmelCase  (       self							:						str      )      ->       Any:
										SCREAMING_SNAKE_CASE     =       ModelOutputTest([("""a""", 30), ("""b""", 10)]      )
										self.assertEqual(list(x.keys()      )							,  ["""a""", """b"""]      )
										self.assertEqual(x.a							,  30      )
										self.assertEqual(x.b							,  10      )

										with self.assertRaises(a      ):
													SCREAMING_SNAKE_CASE     =       ModelOutputTest([("""a""", 30), (10, 10)]      )

										SCREAMING_SNAKE_CASE     =       ModelOutputTest(a=(30, 30)      )
										self.assertEqual(list(x.keys()      )							,  ["""a"""]      )
										self.assertEqual(x.a							,  (30, 30)      )












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


if __name__ == "__main__":
		__A    :				Optional[int]    						=	input("""Enter the string: """).strip()
		__A    :				List[Any]    						=	find_minimum_partitions(s)
		print(f'''Minimum number of partitions required for the \'{s}\' is {ans}''')






