

"""simple docstring"""

from itertools import combinations, product




def       snake_case__	(       lowerCAmelCase   :		int				,					lowerCAmelCase   :		int				,					lowerCAmelCase   :		int				,					lowerCAmelCase   :		int		):
					if xa == ya == 0 or xa == ya == 0:
										return False
					__snake_case          =	xa * xa + ya * ya
					__snake_case          =	xa * xa + ya * ya
					__snake_case          =	(xa - xa) * (xa - xa) + (ya - ya) * (ya - ya)
					return (
					    a_square + b_square == c_square
					    or a_square + c_square == b_square
					    or b_square + c_square == a_square
					)




def       snake_case__	(       lowerCAmelCase   :		int = 50		):
					return sum(
					    1
					    for pta, pta in combinations(product(range(limit + 1		)				,					repeat=2		)				,					2		)
					    if is_right(*lowerCAmelCase				,					*lowerCAmelCase		)		)


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








"""simple docstring"""

import functools
from math import sqrt
from time import time




def       snake_case__	(       lowerCAmelCase   :		int				,					*lowerCAmelCase   :		str				,					**lowerCAmelCase   :		List[Any]		):
					__snake_case          =	time()
					__snake_case          =	func(*lowerCAmelCase				,					**lowerCAmelCase		)
					__snake_case          =	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_000:0.4f} ms'''		)
					return output




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




def       snake_case__	(       lowerCAmelCase   :		int		):

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




def       snake_case__	(       lowerCAmelCase   :		int		):

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




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

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

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

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




def       snake_case__	(       lowerCAmelCase   :		int		):
					if n < 0:
										raise Exception("""n is negative"""		)
					if n >= 1_475:
										raise Exception("""n is too large"""		)
					__snake_case          =	sqrt(5		)
					__snake_case          =	(1 + sqrt_a) / 2
					return [round(phi**i / sqrt_a		) for i in range(n + 1		)]


if __name__ == "__main__":
		UpperCamelCase__ :    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)


