



import sys

sys.set_int_max_str_digits(0)  # type: ignore




def 						UpperCAmelCase (    _lowerCamelCase     ):
			A				:       List[Any]														=    [0] * 11
			A				:       Optional[Any]														=    [0] * 11

			# mark last 9 numbers
			for _ in range(9     ):
						A				:       Tuple														=    1
						A				:       int														=    number // 10
			# flag
			A				:       Dict														=    True

			# check last 9 numbers for pandigitality

			for x in range(9     ):
						if not check_last[x + 1]:
									A				:       List[Any]														=    False
			if not f:
						return f

			# mark first 9 numbers
			A				:       List[Any]														=    int(str(_lowerCamelCase     )[:9]     )

			for _ in range(9     ):
						A				:       Union[str, Any]														=    1
						A				:       Optional[Any]														=    number // 10

			# check first 9 numbers for pandigitality

			for x in range(9     ):
						if not check_front[x + 1]:
									A				:       Optional[Any]														=    False
			return f




def 						UpperCAmelCase (    _lowerCamelCase     ):
			A				:       Optional[Any]														=    [0] * 11

			# mark last 9 numbers
			for _ in range(9     ):
						A				:       str														=    1
						A				:       int														=    number // 10
			# flag
			A				:       List[Any]														=    True

			# check last 9 numbers for pandigitality

			for x in range(9     ):
						if not check_last[x + 1]:
									A				:       Dict														=    False
			return f




def 						UpperCAmelCase (    ):
			A				:       Union[str, Any]														=    1
			A				:       List[str]														=    1
			A				:       Dict														=    2
			# temporary Fibonacci numbers

			A				:       List[Any]														=    1
			A				:       Optional[int]														=    1
			A				:       str														=    2
			# temporary Fibonacci numbers mod 1e9

			# mod m=1e9, done for fast optimisation
			A				:       int														=    [0] * 100_0000
			A				:       Union[str, Any]														=    10_0000_0000

			for x in range(100_0000     ):
						A				:       Any														=    (aa + ba) % m
						A				:       Optional[int]														=    ba % m
						A				:       List[Any]														=    ca % m
						if checka(_lowerCamelCase     ):
									A				:       Optional[Any]														=    1

			for x in range(100_0000     ):
						A				:       List[Any]														=    a + b
						A				:       Union[str, Any]														=    b
						A				:       Optional[int]														=    c
						# perform check only if in tocheck
						if tocheck[x + 3] and check(_lowerCamelCase     ):
									return x + 3  # first 2 already done
			return -1


if __name__ == "__main__":
							print(F"""{solution() = }""")




from collections.abc import Callable

__SCREAMING_SNAKE_CASE     =	Callable[[float], float]  # type alias for a real -> real function




def 						UpperCAmelCase (    _lowerCamelCase			,     _lowerCamelCase			,     _lowerCamelCase			,     ):
			A				:       int														=    float(_lowerCamelCase     )
			while True:
						try:
									A				:       Optional[int]														=    prev_guess - function(_lowerCamelCase     ) / derivative(_lowerCamelCase     )
						except ZeroDivisionError:
									raise ZeroDivisionError("Could not find root"     ) from None
						if abs(prev_guess - next_guess     ) < 10**-5:
									return next_guess
						A				:       Any														=    next_guess




def 						UpperCAmelCase (    _lowerCamelCase     ):
			return (x**3) - (2 * x) - 5




def 						UpperCAmelCase (    _lowerCamelCase     ):
			return 3 * (x**2) - 2


if __name__ == "__main__":
							print(newton(f, fa, 3))