
"""simple docstring"""
def 					a__ ( a :					int							,  a :					int = 1_000		):

  """simple docstring"""







  if (not isinstance(a							,  a		)) or (digit_position <= 0):
    raise ValueError("Digit position must be a positive integer"		)
  elif (not isinstance(a							,  a		)) or (precision < 0):
    raise ValueError("Precision must be a nonnegative integer"		)

  # compute an approximation of (16 ** (n - 1)) * pi whose fractional part is mostly
  # accurate
  _snake_case  :    List[Any]            = (
      4 * _subsum(a							,  1							,  a		)
      - 2 * _subsum(a							,  4							,  a		)
      - _subsum(a							,  5							,  a		)
      - _subsum(a							,  6							,  a		)
  )

  # return the first hex digit of the fractional part of the result
  return hex(int((sum_result % 1) * 16		)		)[2:]
def 					a__ ( a :					int							,  a :					int							,  a :					int		):

  """simple docstring"""







  _snake_case  :    Optional[int]            = 0.0
  for sum_index in range(digit_pos_to_extract + precision		):
    _snake_case  :    Dict            = 8 * sum_index + denominator_addend
    if sum_index < digit_pos_to_extract:
      # if the exponential term is an integer and we mod it by the denominator
      # before dividing, only the integer part of the sum will change;
      # the fractional part will not
      _snake_case  :    List[str]            = pow(
          16							,  digit_pos_to_extract - 1 - sum_index							,  a		)
    else:
      _snake_case  :    List[Any]            = pow(16							,  digit_pos_to_extract - 1 - sum_index		)
    total += exponential_term / denominator
  return total


if __name__ == "__main__":
    import doctest

    doctest.testmod()





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}')