


"""simple docstring"""






import sys

sys.set_int_max_str_digits(0)  # type: ignore





def 							A_					(   snake_case__		)				->     bool:
			_UpperCamelCase				:Tuple				    =  [0] * 11
			_UpperCamelCase				:Optional[Any]				    =  [0] * 11

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

			# check last 9 numbers for pandigitality

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

			# mark first 9 numbers
			_UpperCamelCase				:Dict				    =  int(str(snake_case__		)[:9]		)

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

			# check first 9 numbers for pandigitality

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





def 							A_					(   snake_case__		)				->     bool:
			_UpperCamelCase				:List[str]				    =  [0] * 11

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

			# check last 9 numbers for pandigitality

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





def 							A_					(   )				->     int:
			_UpperCamelCase				:List[Any]				    =  1
			_UpperCamelCase				:Any				    =  1
			_UpperCamelCase				:Tuple				    =  2
			# temporary Fibonacci numbers

			_UpperCamelCase				:Tuple				    =  1
			_UpperCamelCase				:int				    =  1
			_UpperCamelCase				:Optional[Any]				    =  2
			# temporary Fibonacci numbers mod 1e9

			# mod m=1e9, done for fast optimisation
			_UpperCamelCase				:Tuple				    =  [0] * 1_00_00_00
			_UpperCamelCase				:Dict				    =  10_00_00_00_00

			for x in range(1_00_00_00		):
						_UpperCamelCase				:List[str]				    =  (aa + ba) % m
						_UpperCamelCase				:List[str]				    =  ba % m
						_UpperCamelCase				:int				    =  ca % m
						if checka(snake_case__		):
									_UpperCamelCase				:Union[str, Any]				    =  1

			for x in range(1_00_00_00		):
						_UpperCamelCase				:int				    =  a + b
						_UpperCamelCase				:Tuple				    =  b
						_UpperCamelCase				:int				    =  c
						# perform check only if in tocheck
						if tocheck[x + 3] and check(snake_case__		):
									return x + 3  # first 2 already done
			return -1


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





"""simple docstring"""






from __future__ import annotations

from enum import Enum






class     A(     lowerCamelCase__		):

		"""simple docstring"""





		A         =       24
		A         =       21
		A         =       18
		A         =       15
		A         =       12
		A         =       9
		A         =       6
		A         =       3
		A         =       2
		A         =       1
		A         =       -1
		A         =       -2
		A         =       -3
		A         =       -6
		A         =       -9
		A         =       -12
		A         =       -15
		A         =       -18
		A         =       -21
		A         =       -24






class     A(     lowerCamelCase__		):

		"""simple docstring"""





		A         =       8
		A         =       7
		A         =       6
		A         =       5
		A         =       4
		A         =       3
		A         =       2
		A         =       1





def 							A_					(   snake_case__					,				snake_case__					,				snake_case__					,				)				->     float:
			if isinstance(snake_case__					,				snake_case__		):
						_UpperCamelCase				:Tuple				    =  SIUnit[known_prefix.lower()]
			if isinstance(snake_case__					,				snake_case__		):
						_UpperCamelCase				:Optional[int]				    =  SIUnit[unknown_prefix.lower()]
			_UpperCamelCase				:float				    =  known_amount * (
			    10 ** (known_prefix.value - unknown_prefix.value)
			)
			return unknown_amount





def 							A_					(   snake_case__					,				snake_case__					,				snake_case__					,				)				->     float:
			if isinstance(snake_case__					,				snake_case__		):
						_UpperCamelCase				:Any				    =  BinaryUnit[known_prefix.lower()]
			if isinstance(snake_case__					,				snake_case__		):
						_UpperCamelCase				:Dict				    =  BinaryUnit[unknown_prefix.lower()]
			_UpperCamelCase				:float				    =  known_amount * (
			    2 ** ((known_prefix.value - unknown_prefix.value) * 10)
			)
			return unknown_amount


if __name__ == "__main__":
					import doctest

					doctest.testmod()

