





'''simple docstring'''







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_   ):
		a   :   List[Any]     =c_float
		@property
		def   lowerCamelCase__			(  self			):



					'''simple docstring'''

					return sizeof(self.value			)





def    _lowerCAmelCase						(						lowercase					,	lowercase					,	lowercase = 0	)					->					int:
			# < 0 is possible if using a dynamic axis
			if dimension <= 0:
						__lowerCAmelCase											=				fixed_dimension

			dimension -= num_token_to_add
			return dimension





def    _lowerCAmelCase						(						lowercase					,	lowercase	)					->					int:
			return num_parameters * dtype.size







def    _lowerCAmelCase						(						lowercase	)					->					Optional[Union["AutoTokenizer", "AutoFeatureExtractor", "AutoProcessor"]]:
			from .. import AutoFeatureExtractor, AutoProcessor, AutoTokenizer  # tests_ignore

			try:
						return AutoProcessor.from_pretrained(lowercase	)
			except (ValueError, OSError, KeyError):
						__lowerCAmelCase						,       __lowerCAmelCase											=				None, None
						try:
									__lowerCAmelCase											=				AutoTokenizer.from_pretrained(lowercase	)
						except (OSError, KeyError):
									pass
						try:
									__lowerCAmelCase											=				AutoFeatureExtractor.from_pretrained(lowercase	)
						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}')

