



import sys

sys.set_int_max_str_digits(0)  # type: ignore

def 			lowerCAmelCase_  (						_lowercase       :     int)							-> bool:







			"""simple docstring"""
			a__     :		Optional[Any]		 =						[0] * 11
			a__     :		Any		 =						[0] * 11

			# mark last 9 numbers
			for _ in range(9):
						a__     :		Dict		 =						1
						a__     :		Optional[int]		 =						number // 10
			# flag
			a__     :		Union[str, Any]		 =						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__     :		Optional[int]		 =						int(str(_lowercase)[:9])

			for _ in range(9):
						a__     :		Optional[int]		 =						1
						a__     :		int		 =						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 			lowerCAmelCase_  (						_lowercase       :     int)							-> bool:







			"""simple docstring"""
			a__     :		Optional[Any]		 =						[0] * 11

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

			# check last 9 numbers for pandigitality

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

def 			lowerCAmelCase_  (						)							-> int:







			"""simple docstring"""
			a__     :		int		 =						1
			a__     :		Optional[int]		 =						1
			a__     :		Dict		 =						2
			# temporary Fibonacci numbers

			a__     :		List[Any]		 =						1
			a__     :		Any		 =						1
			a__     :		Dict		 =						2
			# temporary Fibonacci numbers mod 1e9

			# mod m=1e9, done for fast optimisation
			a__     :		Tuple		 =						[0] * 100_0000
			a__     :		int		 =						10_0000_0000

			for x in range(100_0000):
						a__     :		Tuple		 =						(aa + ba) % m
						a__     :		Dict		 =						ba % m
						a__     :		List[Any]		 =						ca % m
						if checka(_lowercase):
									a__     :		List[str]		 =						1

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


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









def 			lowerCAmelCase_  (						_lowercase       :     list)							-> bool:







			"""simple docstring"""
			if not isinstance(_lowercase		,     _lowercase):
						raise ValueError("""Input series is not valid, valid series - [1, 2/3, 2]""")
			if len(_lowercase) == 0:
						raise ValueError("""Input list must be a non empty list""")
			if len(_lowercase) == 1 and series[0] != 0:
						return True
			a__     :		Tuple		 =						[]
			a__     :		Union[str, Any]		 =						len(_lowercase)
			for i in range(0		,     _lowercase):
						if series[i] == 0:
									raise ValueError("""Input series cannot have 0 as an element""")
						rec_series.append(1 / series[i])
			a__     :		Dict		 =						rec_series[1] - rec_series[0]
			for index in range(2		,     _lowercase):
						if rec_series[index] - rec_series[index - 1] != common_diff:
									return False
			return True

def 			lowerCAmelCase_  (						_lowercase       :     list)							-> float:







			"""simple docstring"""
			if not isinstance(_lowercase		,     _lowercase):
						raise ValueError("""Input series is not valid, valid series - [2, 4, 6]""")
			if len(_lowercase) == 0:
						raise ValueError("""Input list must be a non empty list""")
			a__     :		Optional[Any]		 =						0
			for val in series:
						answer += 1 / val
			return len(_lowercase) / answer


if __name__ == "__main__":
		import doctest

		doctest.testmod()




