



import functools



def __lowerCAmelCase	(       SCREAMING_SNAKE_CASE_  ,					SCREAMING_SNAKE_CASE_					):

			# Validation
			if not isinstance(SCREAMING_SNAKE_CASE_  ,					SCREAMING_SNAKE_CASE_					) or not all(isinstance(SCREAMING_SNAKE_CASE_  ,					SCREAMING_SNAKE_CASE_					) for day in days					):
						raise ValueError("The parameter days should be a list of integers"					)

			if len(SCREAMING_SNAKE_CASE_					) != 3 or not all(isinstance(SCREAMING_SNAKE_CASE_  ,					SCREAMING_SNAKE_CASE_					) for cost in costs					):
						raise ValueError("The parameter costs should be a list of three integers"					)

			if len(SCREAMING_SNAKE_CASE_					) == 0:
						return 0

			if min(SCREAMING_SNAKE_CASE_					) <= 0:
						raise ValueError("All days elements should be greater than 0"					)

			if max(SCREAMING_SNAKE_CASE_					) >= 366:
						raise ValueError("All days elements should be less than 366"					)

			lowercase__   					=			set(SCREAMING_SNAKE_CASE_					)

			@functools.cache
			def dynamic_programming(SCREAMING_SNAKE_CASE_					) -> int:
						if index > 365:
									return 0

						if index not in days_set:
									return dynamic_programming(index + 1					)

						return min(
						    costs[0] + dynamic_programming(index + 1					)  ,					costs[1] + dynamic_programming(index + 7					)  ,					costs[2] + dynamic_programming(index + 30					)  ,					)

			return dynamic_programming(1					)


if __name__ == "__main__":
							import doctest

							doctest.testmod()









def __lowerCAmelCase	(       SCREAMING_SNAKE_CASE_  ,					SCREAMING_SNAKE_CASE_					):
			lowercase__   					=			1  # To kept the Calculated Value
			# Since C(n, k) = C(n, n-k)
			if k > (n - k):
						lowercase__   					=			n - k
			# Calculate C(n,k)
			for i in range(SCREAMING_SNAKE_CASE_					):
						result *= n - i
						result //= i + 1
			return result



def __lowerCAmelCase	(       SCREAMING_SNAKE_CASE_					):
			return binomial_coefficient(2 * node_count  ,					SCREAMING_SNAKE_CASE_					) // (node_count + 1)



def __lowerCAmelCase	(       SCREAMING_SNAKE_CASE_					):
			if n < 0:
						raise ValueError("factorial() not defined for negative values"					)
			lowercase__   					=			1
			for i in range(1  ,					n + 1					):
						result *= i
			return result



def __lowerCAmelCase	(       SCREAMING_SNAKE_CASE_					):
			return catalan_number(SCREAMING_SNAKE_CASE_					) * factorial(SCREAMING_SNAKE_CASE_					)


if __name__ == "__main__":
							lowercase_						=       int(input("""Enter the number of nodes: """).strip() or 0)
							if node_count <= 0:
														raise ValueError("""We need some nodes to work with.""")
							print(
							    F'Given {node_count} nodes, there are {binary_tree_count(node_count)} '
							    F'binary trees and {catalan_number(node_count)} binary search trees.'
							)




