

import functools
from math import sqrt
from time import time



def  __lowerCAmelCase (  A    ,       *A    ,       **A      ):
	UpperCAmelCase_    			=     time()
	UpperCAmelCase_    			=     func(*A    ,       **A      )
	UpperCAmelCase_    			=     time()
	if int(end - start      ) > 0:
		print(F"{func.__name__} runtime: {(end - start):0.4f} s"      )
	else:
		print(F"{func.__name__} runtime: {(end - start) * 1000:0.4f} ms"      )
	return output



def  __lowerCAmelCase (  A      ):
	if n < 0:
		raise Exception("n is negative"      )
	if n == 0:
		return [0]
	UpperCAmelCase_    			=     [0, 1]
	for _ in range(n - 1      ):
		fib.append(fib[-1] + fib[-2]      )
	return fib



def  __lowerCAmelCase (  A      ):

	def fib_recursive_term(A      ) -> int:
		if i < 0:
			raise Exception("n is negative"      )
		if i < 2:
			return i
		return fib_recursive_term(i - 1      ) + fib_recursive_term(i - 2      )

	if n < 0:
		raise Exception("n is negative"      )
	return [fib_recursive_term(A      ) for i in range(n + 1      )]



def  __lowerCAmelCase (  A      ):

	@functools.cache
	def fib_recursive_term(A      ) -> int:
		if i < 0:
			raise Exception("n is negative"      )
		if i < 2:
			return i
		return fib_recursive_term(i - 1      ) + fib_recursive_term(i - 2      )

	if n < 0:
		raise Exception("n is negative"      )
	return [fib_recursive_term(A      ) for i in range(n + 1      )]



def  __lowerCAmelCase (  A      ):
	if n < 0:
		raise Exception("n is negative"      )
	# Cache must be outside recursuive function
	# other it will reset every time it calls itself.
	UpperCAmelCase_    			=     {0: 0, 1: 1, 2: 1}  # Prefilled cache

	def rec_fn_memoized(A      ) -> int:
		if num in cache:
			return cache[num]

		UpperCAmelCase_    			=     rec_fn_memoized(num - 1      ) + rec_fn_memoized(num - 2      )
		UpperCAmelCase_    			=     value
		return value

	return [rec_fn_memoized(A      ) for i in range(n + 1      )]



def  __lowerCAmelCase (  A      ):
	if n < 0:
		raise Exception("n is negative"      )
	if n >= 1475:
		raise Exception("n is too large"      )
	UpperCAmelCase_    			=     sqrt(5      )
	UpperCAmelCase_    			=     (1 + sqrt_a) / 2
	return [round(phi**i / sqrt_a      ) for i in range(n + 1      )]


if __name__ == "__main__":
				_a:      List[str]								=     30
				time_func(fib_iterative, num)
				time_func(fib_recursive, num)  # Around 3s runtime
				time_func(fib_recursive_cached, num)  # Around 0ms runtime
				time_func(fib_memoization, num)
				time_func(fib_binet, num)


def  __lowerCAmelCase (  A      ):
	UpperCAmelCase_    			=     len(A      )

	# Set the gap value to be decreased by a factor of 1.3
	# after each iteration
	UpperCAmelCase_    			=     1.3

	# Continue sorting until the gap is 1
	while gap > 1:
		# Decrease the gap value
		UpperCAmelCase_    			=     int(gap / shrink      )

		# Sort the elements using insertion sort
		for i in range(A    ,       len(A      )      ):
			UpperCAmelCase_    			=     collection[i]
			UpperCAmelCase_    			=     i
			while j >= gap and collection[j - gap] > temp:
				UpperCAmelCase_    			=     collection[j - gap]
				j -= gap
			UpperCAmelCase_    			=     temp

	return collection


if __name__ == "__main__":
				import doctest

				doctest.testmod()