



import functools
from math import sqrt
from time import time
def 						snake_case__							(       __lowercase				,  *__lowercase				,  **__lowercase							)		->		str:







						"""simple docstring"""

						A__						:				int         =			time()
						A__						:				List[Any]         =			func(*__lowercase				,  **__lowercase							)
						A__						:				Tuple         =			time()
						if int(end - start							) > 0:
												print(F'{func.__name__} runtime: {(end - start):0.4f} s'							)
						else:
												print(F'{func.__name__} runtime: {(end - start) * 1_0_0_0:0.4f} ms'							)
						return output
def 						snake_case__							(       __lowercase							)		->		list[int]:







						"""simple docstring"""

						if n < 0:
												raise Exception("n is negative"							)
						if n == 0:
												return [0]
						A__						:				List[Any]         =			[0, 1]
						for _ in range(n - 1							):
												fib.append(fib[-1] + fib[-2]							)
						return fib
def 						snake_case__							(       __lowercase							)		->		list[int]:







						"""simple docstring"""

						def fib_recursive_term(__lowercase							) -> 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(__lowercase							) for i in range(n + 1							)]
def 						snake_case__							(       __lowercase							)		->		list[int]:







						"""simple docstring"""

						@functools.cache
						def fib_recursive_term(__lowercase							) -> 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(__lowercase							) for i in range(n + 1							)]
def 						snake_case__							(       __lowercase							)		->		list[int]:







						"""simple docstring"""

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

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

												A__						:				Tuple         =			rec_fn_memoized(num - 1							) + rec_fn_memoized(num - 2							)
												A__						:				Optional[int]         =			value
												return value

						return [rec_fn_memoized(__lowercase							) for i in range(n + 1							)]
def 						snake_case__							(       __lowercase							)		->		list[int]:







						"""simple docstring"""

						if n < 0:
												raise Exception("n is negative"							)
						if n >= 1_4_7_5:
												raise Exception("n is too large"							)
						A__						:				List[Any]         =			sqrt(5							)
						A__						:				Optional[int]         =			(1 + sqrt_a) / 2
						return [round(phi**i / sqrt_a							) for i in range(n + 1							)]


if __name__ == "__main__":
		snake_case     :    Any						=    3_0
		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 						snake_case__							(       __lowercase							)		->		int:







						"""simple docstring"""

						A__						:				Any         =			0
						for plain_chr in plain_text:
												A__						:				List[str]         =			(
												    ord(__lowercase							) + (hash_value << 6) + (hash_value << 1_6) - hash_value
												)
						return hash_value