





'''simple docstring'''






def      lowercase  (  lowerCAmelCase :						list   , lowerCAmelCase :						int   , lowerCAmelCase :						int   , lowerCAmelCase :						int):



				"""simple docstring"""


				_A :				Union[str, Any]				=  int((lower_bound + upper_bound) // 2)
				if array[r] == value:
								return r
				if lower_bound >= upper_bound:
								return -1
				if array[r] < value:
								return binary_search(lowerCAmelCase   , r + 1   , lowerCAmelCase   , lowerCAmelCase)
				else:
								return binary_search(lowerCAmelCase   , lowerCAmelCase   , r - 1   , lowerCAmelCase)





def      lowercase  (  lowerCAmelCase :						int   , lowerCAmelCase :						list):



				"""simple docstring"""


				_A :				Any				=  0
				if matrix[index][0] == value:
								return [index, 0]
				while index < len(lowerCAmelCase) and matrix[index][0] < value:
								_A :				Union[str, Any]				=  binary_search(matrix[index]   , 0   , len(matrix[index]) - 1   , lowerCAmelCase)
								if r != -1:
												return [index, r]
								index += 1
				return [-1, -1]


if __name__ == "__main__":
	import doctest

	doctest.testmod()







'''simple docstring'''






import sys

sys.set_int_max_str_digits(0)  # type: ignore





def      lowercase  (  lowerCAmelCase :						int):



				"""simple docstring"""


				_A :				List[Any]				=  [0] * 11
				_A :				Optional[Any]				=  [0] * 11

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

				# check last 9 numbers for pandigitality

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

				# mark first 9 numbers
				_A :				str				=  int(str(lowerCAmelCase)[:9])

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

				# check first 9 numbers for pandigitality

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





def      lowercase  (  lowerCAmelCase :						int):



				"""simple docstring"""


				_A :				Tuple				=  [0] * 11

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

				# check last 9 numbers for pandigitality

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





def      lowercase  (  ):



				"""simple docstring"""


				_A :				Union[str, Any]				=  1
				_A :				Tuple				=  1
				_A :				List[str]				=  2
				# temporary Fibonacci numbers

				_A :				List[str]				=  1
				_A :				str				=  1
				_A :				List[str]				=  2
				# temporary Fibonacci numbers mod 1e9

				# mod m=1e9, done for fast optimisation
				_A :				Any				=  [0] * 100_0000
				_A :				List[Any]				=  10_0000_0000

				for x in range(100_0000):
								_A :				Dict				=  (aa + ba) % m
								_A :				str				=  ba % m
								_A :				Union[str, Any]				=  ca % m
								if checka(lowerCAmelCase):
												_A :				List[str]				=  1

				for x in range(100_0000):
								_A :				str				=  a + b
								_A :				List[str]				=  b
								_A :				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() = }')
