



'''simple docstring'''




import sys

sys.set_int_max_str_digits(0)  # type: ignore


def     lowerCAmelCase_       (     _lowerCamelCase:       int ):
		__SCREAMING_SNAKE_CASE	:		Dict   	=		[0] * 11
		__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		[0] * 11

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

		# check last 9 numbers for pandigitality

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

		# mark first 9 numbers
		__SCREAMING_SNAKE_CASE	:		Dict   	=		int(str(_lowerCamelCase )[:9] )

		for _ in range(9 ):
				__SCREAMING_SNAKE_CASE	:		Dict   	=		1
				__SCREAMING_SNAKE_CASE	:		Optional[int]   	=		number // 10

		# check first 9 numbers for pandigitality

		for x in range(9 ):
				if not check_front[x + 1]:
						__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		False
		return f


def     lowerCAmelCase_       (     _lowerCamelCase:       int ):
		__SCREAMING_SNAKE_CASE	:		Optional[int]   	=		[0] * 11

		# mark last 9 numbers
		for _ in range(9 ):
				__SCREAMING_SNAKE_CASE	:		Optional[Any]   	=		1
				__SCREAMING_SNAKE_CASE	:		str   	=		number // 10
		# flag
		__SCREAMING_SNAKE_CASE	:		Dict   	=		True

		# check last 9 numbers for pandigitality

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


def     lowerCAmelCase_       (     ):
		__SCREAMING_SNAKE_CASE	:		List[str]   	=		1
		__SCREAMING_SNAKE_CASE	:		List[str]   	=		1
		__SCREAMING_SNAKE_CASE	:		Optional[int]   	=		2
		# temporary Fibonacci numbers

		__SCREAMING_SNAKE_CASE	:		Tuple   	=		1
		__SCREAMING_SNAKE_CASE	:		Dict   	=		1
		__SCREAMING_SNAKE_CASE	:		str   	=		2
		# temporary Fibonacci numbers mod 1e9

		# mod m=1e9, done for fast optimisation
		__SCREAMING_SNAKE_CASE	:		int   	=		[0] * 1_00_00_00
		__SCREAMING_SNAKE_CASE	:		str   	=		10_00_00_00_00

		for x in range(1_00_00_00 ):
				__SCREAMING_SNAKE_CASE	:		Tuple   	=		(aa + ba) % m
				__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		ba % m
				__SCREAMING_SNAKE_CASE	:		Tuple   	=		ca % m
				if checka(_lowerCamelCase ):
						__SCREAMING_SNAKE_CASE	:		Tuple   	=		1

		for x in range(1_00_00_00 ):
				__SCREAMING_SNAKE_CASE	:		Any   	=		a + b
				__SCREAMING_SNAKE_CASE	:		Optional[int]   	=		b
				__SCREAMING_SNAKE_CASE	:		Optional[Any]   	=		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() = }")




'''simple docstring'''




UpperCamelCase__	:     List[Any]    =			10_00


def     lowerCAmelCase_       (     _lowerCamelCase:       float ):
		return x * x


def     lowerCAmelCase_       (     _lowerCamelCase:       Any	,				_lowerCamelCase:       float	,				_lowerCamelCase:       float	,				_lowerCamelCase:       int = 4 ):
		assert callable(
		    _lowerCamelCase ), F"the function(object) passed should be callable your input : {function}"
		assert isinstance(_lowerCamelCase	,				(float, int) ), F"a should be float or integer your input : {a}"
		assert isinstance(function(_lowerCamelCase )	,				(float, int) ), (
		    "the function should return integer or float return type of your function, "
		    F"{type(_lowerCamelCase )}"
		)
		assert isinstance(_lowerCamelCase	,				(float, int) ), F"b should be float or integer your input : {b}"
		assert (
		    isinstance(_lowerCamelCase	,				_lowerCamelCase ) and precision > 0
		), F"precision should be positive integer your input : {precision}"

		# just applying the formula of simpson for approximate integration written in
		# mentioned article in first comment of this file and above this function

		__SCREAMING_SNAKE_CASE	:		List[Any]   	=		(b - a) / N_STEPS
		__SCREAMING_SNAKE_CASE	:		List[Any]   	=		function(_lowerCamelCase ) + function(_lowerCamelCase )

		for i in range(1	,				_lowerCamelCase ):
				__SCREAMING_SNAKE_CASE	:		Union[str, Any]   	=		a + h * i
				result += function(_lowerCamelCase ) * (4 if i % 2 else 2)

		result *= h / 3
		return round(_lowerCamelCase	,				_lowerCamelCase )


if __name__ == "__main__":
						import doctest

						doctest.testmod()