'''simple docstring'''




import functools
from math import sqrt
from time import time





def      _UpperCAmelCase    (							_UpperCamelCase    :	List[Any],   *_UpperCamelCase    :	Dict,   **_UpperCamelCase    :	Optional[int]   )	->      Tuple:
    A_     =   time()
    A_     =   func(*__UpperCAmelCase,   **__UpperCAmelCase   )
    A_     =   time()
    if int(end - start   ) > 0:
        print(F'''{func.__name__} runtime: {(end - start):0.4f} s'''   )
    else:
        print(F'''{func.__name__} runtime: {(end - start) * 10_00:0.4f} ms'''   )
    return output





def      _UpperCAmelCase    (							_UpperCamelCase    :	Dict   )	->      List[str]:
    if n < 0:
        raise Exception('''n is negative'''   )
    if n == 0:
        return [0]
    A_     =   [0, 1]
    for _ in range(n - 1   ):
        fib.append(fib[-1] + fib[-2]   )
    return fib





def      _UpperCAmelCase    (							_UpperCamelCase    :	str   )	->      Union[str, Any]:

    def fib_recursive_term(_UpperCamelCase    :	Tuple   ) -> 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(__UpperCAmelCase   ) for i in range(n + 1   )]





def      _UpperCAmelCase    (							_UpperCamelCase    :	str   )	->      List[Any]:

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





def      _UpperCAmelCase    (							_UpperCamelCase    :	str   )	->      Tuple:
    if n < 0:
        raise Exception('''n is negative'''   )
    # Cache must be outside recursuive function
    # other it will reset every time it calls itself.
    A_     =   {0: 0, 1: 1, 2: 1}  # Prefilled cache

    def rec_fn_memoized(_UpperCamelCase    :	List[str]   ) -> int:
        if num in cache:
            return cache[num]

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

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





def      _UpperCAmelCase    (							_UpperCamelCase    :	Tuple   )	->      str:
    if n < 0:
        raise Exception('''n is negative'''   )
    if n >= 14_75:
        raise Exception('''n is too large'''   )
    A_     =   sqrt(5   )
    A_     =   (1 + sqrt_a) / 2
    return [round(phi**i / sqrt_a   ) for i in range(n + 1   )]


if __name__ == "__main__":
  __snake_case   :      Optional[Any]						    =  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)











"""simple docstring"""







from itertools import combinations_with_replacement


def       __SCREAMING_SNAKE_CASE      (   __UpperCAmelCase = 100	):
		_lowercase							:      list[int]			=					[*list(range(1					,							21	)	), 25]
		_lowercase							:      list[int]			=					[2 * x for x in range(1					,							21	)] + [50]
		_lowercase							:      list[int]			=					[3 * x for x in range(1					,							21	)]
		_lowercase							:      list[int]			=					singles + doubles + triples + [0]

		_lowercase							:      int			=					0
		_lowercase							:      int
		_lowercase							:      int
		_lowercase							:      int
		_lowercase							:      int

		for double in doubles:
				for throwa, throwa in combinations_with_replacement(__UpperCAmelCase					,							2	):
						_lowercase							:      Union[str, Any]			=					double + throwa + throwa
						if checkout_total < limit:
								num_checkouts += 1

		return num_checkouts


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



