






from ctypes import c_float, sizeof
from enum import Enum
from typing import TYPE_CHECKING, Optional, Union


if TYPE_CHECKING:
							from .. import AutoFeatureExtractor, AutoProcessor, AutoTokenizer  # tests_ignore




class 						UpperCAmelCase_  (		lowerCAmelCase_    ):


						'''simple docstring'''




						A   :      List[Any]						 =    c_float






						@property
						def 					_lowerCAmelCase				(		self )       -> Optional[int]:
								return sizeof(self.value )




def    lowerCAmelCase__		(			_a				:	str     ,					_a				:	Any     ,					_a				:	List[str] = 0			):
		# < 0 is possible if using a dynamic axis
		if dimension <= 0:
				snake_case_ :							Optional[Any]         =				fixed_dimension

		dimension -= num_token_to_add
		return dimension

def    lowerCAmelCase__		(			_a				:	List[str]     ,					_a				:	Tuple			):
		return num_parameters * dtype.size

def    lowerCAmelCase__		(			_a				:	Optional[Any]			):
		from .. import AutoFeatureExtractor, AutoProcessor, AutoTokenizer  # tests_ignore

		try:
				return AutoProcessor.from_pretrained(_a			)
		except (ValueError, OSError, KeyError):
				snake_case_       ,				snake_case_ :							Optional[Any]         =				None, None
				try:
						snake_case_ :							Dict         =				AutoTokenizer.from_pretrained(_a			)
				except (OSError, KeyError):
						pass
				try:
						snake_case_ :							Dict         =				AutoFeatureExtractor.from_pretrained(_a			)
				except (OSError, KeyError):
						pass

				if tokenizer is not None and feature_extractor is not None:
						raise ValueError(
						    F'''Couldn\'t auto-detect preprocessor for {model_name}. Found both a tokenizer and a feature extractor.'''			)
				elif tokenizer is None and feature_extractor is None:
						return None
				elif tokenizer is not None:
						return tokenizer
				else:
						return feature_extractor







'''simple docstring'''







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


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

