


from __future__ import annotations

from typing import Generic, TypeVar

_A							     =       TypeVar('T')

class 			lowerCamelCase_					(    Generic[T]    ):





							def __init__(							self			,       _SCREAMING_SNAKE_CASE    ):
								a_     			=   data  # Assign data
								a_     			=   None  # Initialize next as null
								a_     			=   None  # Initialize prev as null







class 			lowerCamelCase_					(    Generic[T]    ):





							def __init__(							self    ):
								a_     			=   None





							def   __magic_name__      (							self			,       _SCREAMING_SNAKE_CASE    ):
								if self.head is None:
									a_     			=   Node(_SCREAMING_SNAKE_CASE    )
								else:
									a_     			=   Node(_SCREAMING_SNAKE_CASE    )
									a_     			=   new_node
									a_     			=   self.head
									a_     			=   None
									a_     			=   new_node





							def   __magic_name__      (							self    ):
								if self.head is None:
									return None
								else:
									assert self.head is not None
									a_     			=   self.head.data
									a_     			=   self.head.next
									if self.head is not None:
										a_     			=   None
									return temp





							def   __magic_name__      (							self    ):
								return self.head.data if self.head is not None else None





							def __len__(							self    ):
								a_     			=   self.head
								a_     			=   0
								while temp is not None:
									count += 1
									a_     			=   temp.next
								return count





							def   __magic_name__      (							self    ):
								return self.head is None





							def   __magic_name__      (							self    ):
								print("""stack elements are:"""    )
								a_     			=   self.head
								while temp is not None:
									print(temp.data			,       end="""->"""    )
									a_     			=   temp.next


# Code execution starts here
if __name__ == "__main__":
			# Start with the empty stack
			_A							     =       Stack()

			# Insert 4 at the beginning. So stack becomes 4->None
			print('Stack operations using Doubly LinkedList')
			stack.push(4)

			# Insert 5 at the beginning. So stack becomes 4->5->None
			stack.push(5)

			# Insert 6 at the beginning. So stack becomes 4->5->6->None
			stack.push(6)

			# Insert 7 at the beginning. So stack becomes 4->5->6->7->None
			stack.push(7)

			# Print the stack
			stack.print_stack()

			# Print the top element
			print('\nTop element is ', stack.top())

			# Print the stack size
			print('Size of the stack is ', len(stack))

			# pop the top element
			stack.pop()

			# pop the top element
			stack.pop()

			# two elements have now been popped off
			stack.print_stack()

			# Print True if the stack is empty else False
			print('\nstack is empty:', stack.is_empty())



def 			__SCREAMING_SNAKE_CASE		(		UpperCamelCase		:      str	)     ->	int:



	"""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							     =       input('Enter the string: ').strip()
			_A							     =       find_minimum_partitions(s)
			print(f'Minimum number of partitions required for the \'{s}\' is {ans}')