




def 							_UpperCAmelCase     (UpperCamelCase_       :       list[list[int]]					,			UpperCamelCase_       :       list[list[int]]				):
				'''simple docstring'''
				_lowerCAmelCase			:			Any        =					[]
				_lowerCAmelCase			:			Optional[Any]        =					len(UpperCamelCase_				)
				for i in range(UpperCamelCase_				):
								_lowerCAmelCase			:			int        =					[]
								for j in range(UpperCamelCase_				):
												_lowerCAmelCase			:			List[Any]        =					0
												for k in range(UpperCamelCase_				):
																_lowerCAmelCase			:			Tuple        =					val + matrix_a[i][k] * matrix_b[k][j]
												list_a.append(UpperCamelCase_				)
								matrix_c.append(UpperCamelCase_				)
				return matrix_c




def 							_UpperCAmelCase     (UpperCamelCase_       :       int				):
				'''simple docstring'''
				return [[int(row == column				) for column in range(UpperCamelCase_				)] for row in range(UpperCamelCase_				)]




def 							_UpperCAmelCase     (UpperCamelCase_       :       int				):
				'''simple docstring'''
				if n <= 1:
								return n
				_lowerCAmelCase			:			Union[str, Any]        =					identity(2				)
				_lowerCAmelCase			:			List[Any]        =					[[1, 1], [1, 0]]
				_lowerCAmelCase			:			Union[str, Any]        =					n - 1
				while n > 0:
								if n % 2 == 1:
												_lowerCAmelCase			:			int        =					multiply(UpperCamelCase_					,			UpperCamelCase_				)
								_lowerCAmelCase			:			Optional[Any]        =					multiply(UpperCamelCase_					,			UpperCamelCase_				)
								_lowerCAmelCase			:			Dict        =					int(n / 2				)
				return res_matrix[0][0]




def 							_UpperCAmelCase     (UpperCamelCase_       :       int				):
				'''simple docstring'''
				if n <= 1:
								return n
				_lowerCAmelCase			:			Dict        =					0
				_lowerCAmelCase			:			Optional[int]        =					1
				for _ in range(2					,			n + 1				):
								_lowerCAmelCase    ,			_lowerCAmelCase			:			Optional[int]        =					fiba, fiba + fiba
				return fiba




def 							_UpperCAmelCase     ():
				'''simple docstring'''
				for ordinal in "0th 1st 2nd 3rd 10th 100th 1000th".split():
								_lowerCAmelCase			:			Dict        =					int("""""".join(c for c in ordinal if c in """0123456789"""				)				)  # 1000th --> 1000
								print(
								    F"{ordinal} fibonacci number using matrix exponentiation is "
								    F"{nth_fibonacci_matrix(UpperCamelCase_				)} and using bruteforce is "
								    F"{nth_fibonacci_bruteforce(UpperCamelCase_				)}\n"				)
				# from timeit import timeit
				# print(timeit("nth_fibonacci_matrix(1000000)",
				#              "from main import nth_fibonacci_matrix", number=5))
				# print(timeit("nth_fibonacci_bruteforce(1000000)",
				#              "from main import nth_fibonacci_bruteforce", number=5))
				# 2.3342058970001744
				# 57.256506615000035


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	main()


def 							lowerCAmelCase(	__lowerCamelCase      ,				__lowerCamelCase						):
					sequence.append(__lowerCamelCase						)

					__a							=   0
					while sequence[index] != target:
										index += 1

					sequence.pop()

					if index == len(__lowerCamelCase						):
										return None

					return index


if __name__ == "__main__":
	lowerCamelCase_				:		List[str]       						=       input("""Enter numbers separated by comma:\n""").strip()
	lowerCamelCase_				:		str       						=       [int(item) for item in user_input.split(""",""")]

	lowerCamelCase_				:		Tuple       						=       input("""Enter a single number to be found in the list:\n""")
	lowerCamelCase_				:		Optional[int]       						=       int(target_input)
	lowerCamelCase_				:		List[Any]       						=       sentinel_linear_search(sequence, target)
	if result is not None:
		print(F'''{target} found at positions: {result}''')
	else:
		print("""Not found""")




