


def _lowerCamelCase			(	_UpperCamelCase   ):

			'''simple docstring'''




			if upper_limit < 0:
						raise ValueError("Limit for the Catalan sequence must be ≥ 0"   )

			__lowerCAmelCase       					=    [0] * (upper_limit + 1)

			# Base case: C(0) = C(1) = 1
			__lowerCAmelCase       					=    1
			if upper_limit > 0:
						__lowerCAmelCase       					=    1

			# Recurrence relation: C(i) = sum(C(j).C(i-j-1)), from j = 0 to i
			for i in range(2					,				upper_limit + 1   ):
						for j in range(lowercase_   ):
									catalan_list[i] += catalan_list[j] * catalan_list[i - j - 1]

			return catalan_list


if __name__ == "__main__":
	print("\n********* Catalan Numbers Using Dynamic Programming ************\n")
	print("\n*** Enter -1 at any time to quit ***")
	print("\nEnter the upper limit (≥ 0) for the Catalan number sequence: ", end="")
	try:
		while True:
			A  :     List[Any]    					=    int(input().strip())
			if N < 0:
				print("\n********* Goodbye!! ************")
				break
			else:
				print(f'''The Catalan numbers from 0 through {N} are:''')
				print(catalan_numbers(N))
				print("Try another upper limit for the sequence: ", end="")
	except (NameError, ValueError):
		print("\n********* Invalid input, goodbye! ************\n")

	import doctest

	doctest.testmod()








"""simple docstring"""


import flax.linen as nn
import jax
import jax.numpy as jnp
class 						_UpperCamelCase						(     nn.Module	):
							'''simple docstring'''







							__UpperCAmelCase		:					int
							__UpperCAmelCase		:					jnp.dtype          =jnp.floataa

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    nn.Conv(
										    self.out_channels					,     kernel_size=(3, 3)					,     strides=(1, 1)					,     padding=((1, 1), (1, 1))					,     dtype=self.dtype					,     )



							def __call__(  self					,     __a			):
										__lowerCAmelCase					,			__lowerCAmelCase					,			__lowerCAmelCase					,			__lowerCAmelCase       					=    hidden_states.shape
										__lowerCAmelCase       					=    jax.image.resize(
										    __a					,     shape=(batch, height * 2, width * 2, channels)					,     method="nearest"					,     )
										__lowerCAmelCase       					=    self.conv(__a			)
										return hidden_states
class 						_UpperCamelCase						(     nn.Module	):
							'''simple docstring'''







							__UpperCAmelCase		:					int
							__UpperCAmelCase		:					jnp.dtype          =jnp.floataa

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    nn.Conv(
										    self.out_channels					,     kernel_size=(3, 3)					,     strides=(2, 2)					,     padding=((1, 1), (1, 1))					,     dtype=self.dtype					,     )



							def __call__(  self					,     __a			):
										# pad = ((0, 0), (0, 1), (0, 1), (0, 0))  # pad height and width dim
										# hidden_states = jnp.pad(hidden_states, pad_width=pad)
										__lowerCAmelCase       					=    self.conv(__a			)
										return hidden_states
class 						_UpperCamelCase						(     nn.Module	):
							'''simple docstring'''







							__UpperCAmelCase		:					int
							__UpperCAmelCase		:					int          =None
							__UpperCAmelCase		:					float          =0.0
							__UpperCAmelCase		:					bool          =None
							__UpperCAmelCase		:					jnp.dtype          =jnp.floataa

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    self.in_channels if self.out_channels is None else self.out_channels

										__lowerCAmelCase       					=    nn.GroupNorm(num_groups=32					,     epsilon=1e-5			)
										__lowerCAmelCase       					=    nn.Conv(
										    __a					,     kernel_size=(3, 3)					,     strides=(1, 1)					,     padding=((1, 1), (1, 1))					,     dtype=self.dtype					,     )

										__lowerCAmelCase       					=    nn.Dense(__a					,     dtype=self.dtype			)

										__lowerCAmelCase       					=    nn.GroupNorm(num_groups=32					,     epsilon=1e-5			)
										__lowerCAmelCase       					=    nn.Dropout(self.dropout_prob			)
										__lowerCAmelCase       					=    nn.Conv(
										    __a					,     kernel_size=(3, 3)					,     strides=(1, 1)					,     padding=((1, 1), (1, 1))					,     dtype=self.dtype					,     )

										__lowerCAmelCase       					=    self.in_channels != out_channels if self.use_nin_shortcut is None else self.use_nin_shortcut

										__lowerCAmelCase       					=    None
										if use_nin_shortcut:
													__lowerCAmelCase       					=    nn.Conv(
													    __a					,     kernel_size=(1, 1)					,     strides=(1, 1)					,     padding="VALID"					,     dtype=self.dtype					,     )



							def __call__(  self					,     __a					,     __a					,     __a=True			):
										__lowerCAmelCase       					=    hidden_states
										__lowerCAmelCase       					=    self.norma(__a			)
										__lowerCAmelCase       					=    nn.swish(__a			)
										__lowerCAmelCase       					=    self.conva(__a			)

										__lowerCAmelCase       					=    self.time_emb_proj(nn.swish(__a			)			)
										__lowerCAmelCase       					=    jnp.expand_dims(jnp.expand_dims(__a					,     1			)					,     1			)
										__lowerCAmelCase       					=    hidden_states + temb

										__lowerCAmelCase       					=    self.norma(__a			)
										__lowerCAmelCase       					=    nn.swish(__a			)
										__lowerCAmelCase       					=    self.dropout(__a					,     __a			)
										__lowerCAmelCase       					=    self.conva(__a			)

										if self.conv_shortcut is not None:
													__lowerCAmelCase       					=    self.conv_shortcut(__a			)

										return hidden_states + residual




