"""simple docstring"""



from itertools import permutations

def    _A(		lowerCAmelCase = 5       ):
							if gon_side < 3 or gon_side > 5:
														raise ValueError("""gon_side must be in the range [3, 5]"""       )

							# Since it's 16, we know 10 is on the outer ring
							# Put the big numbers at the end so that they are never the first number
							A__					:    List[Any]														= list(range(gon_side + 1 ,     0 ,     -1       )       )
							A__					:    List[str]														= list(range(gon_side + 2 ,     gon_side * 2 + 1       )       )

							for perm in permutations(small_numbers + big_numbers       ):
														A__					:    List[str]														= generate_gon_ring(lowerCAmelCase ,     list(lowerCAmelCase       )       )
														if is_magic_gon(lowerCAmelCase       ):
																					return int("""""".join(str(lowerCAmelCase       ) for n in numbers       )       )

							A__					:    int														= F'''Magic {gon_side}-gon ring is impossible'''
							raise ValueError(lowerCAmelCase       )

def    _A(		lowerCAmelCase ,     lowerCAmelCase       ):
							A__					:    Union[str, Any]														= [0] * (gon_side * 3)
							A__					:    Dict														= perm[0:3]
							perm.append(perm[1]       )

							A__					:    Any														= 1 if gon_side < 5 else 2

							for i in range(1 ,     len(lowerCAmelCase       ) // 3 + magic_number       ):
														A__					:    Dict														= perm[2 * i + 1]
														A__					:    List[str]														= result[3 * i - 1]
														A__					:    Dict														= perm[2 * i + 2]

							return result

def    _A(		lowerCAmelCase       ):
							if len(lowerCAmelCase       ) % 3 != 0:
														raise ValueError("""a gon ring should have a length that is a multiple of 3"""       )

							if min(numbers[::3]       ) != numbers[0]:
														return False

							A__					:    List[str]														= sum(numbers[:3]       )

							return all(sum(numbers[i : i + 3]       ) == total for i in range(3 ,     len(lowerCAmelCase       ) ,     3       )       )


if __name__ == "__main__":
				print(solution())






"""simple docstring"""



def    _A(		lowerCAmelCase       ):
							A__					:    str														= len(lowerCAmelCase       )
							A__					:    List[Any]														= [0] * length
							A__					:    Union[str, Any]														= [[False for i in range(lowerCAmelCase       )] for j in range(lowerCAmelCase       )]
							for i, c in enumerate(lowerCAmelCase       ):
														A__					:    Dict														= i
														for j in range(i + 1       ):
																					if c == string[j] and (i - j < 2 or is_palindromic[j + 1][i - 1]):
																												A__					:    List[str]														= True
																												A__					:    Optional[Any]														= min(lowerCAmelCase ,     0 if j == 0 else (cut[j - 1] + 1)       )
														A__					:    Optional[int]														= mincut
							return cut[length - 1]


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





