


def        UpperCamelCase_(				_A   :int  )->		"list[int]":
			if upper_limit < 0:
						raise ValueError("Limit for the Catalan sequence must be ≥ 0"  )

			UpperCamelCase__					=       [0] * (upper_limit + 1)

			# Base case: C(0) = C(1) = 1
			UpperCamelCase__					=       1
			if upper_limit > 0:
						UpperCamelCase__					=       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(_A  ):
									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:
																		__UpperCamelCase    		=       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()






from collections import deque
def        UpperCamelCase_(				_A   :Union[str, Any]  )->		List[Any]:
			UpperCamelCase__					=       len(_A  )
			UpperCamelCase__					=       deque()
			UpperCamelCase__					=       [False for _ in range(_A  )]
			UpperCamelCase__					=       [-1 for _ in range(_A  )]
			UpperCamelCase__					=       index_of[:]

			def strong_connect(_A   :Optional[int]				,     _A   :Optional[int]				,     _A   :List[Any]  ):
						UpperCamelCase__					=       index  # the number when this node is seen
						UpperCamelCase__					=       index  # lowest rank node reachable from here
						index += 1
						stack.append(_A  )
						UpperCamelCase__					=       True

						for w in g[v]:
									if index_of[w] == -1:
												UpperCamelCase__					=       strong_connect(_A				,     _A				,     _A  )
												UpperCamelCase__					=       (
												    lowlink_of[w] if lowlink_of[w] < lowlink_of[v] else lowlink_of[v]
												)
									elif on_stack[w]:
												UpperCamelCase__					=       (
												    lowlink_of[w] if lowlink_of[w] < lowlink_of[v] else lowlink_of[v]
												)

						if lowlink_of[v] == index_of[v]:
									UpperCamelCase__					=       []
									UpperCamelCase__					=       stack.pop()
									UpperCamelCase__					=       False
									component.append(_A  )
									while w != v:
												UpperCamelCase__					=       stack.pop()
												UpperCamelCase__					=       False
												component.append(_A  )
									components.append(_A  )
						return index

			UpperCamelCase__					=       []
			for v in range(_A  ):
						if index_of[v] == -1:
									strong_connect(_A				,     0				,     _A  )

			return components
def        UpperCamelCase_(				_A   :Optional[Any]				,     _A   :Any  )->		Union[str, Any]:
			UpperCamelCase__					=       [[] for _ in range(_A  )]
			for u, v in edges:
						g[u].append(_A  )
			return g


if __name__ == "__main__":
						# Test
						__UpperCamelCase    		=       7
						__UpperCamelCase    		=       [0, 0, 1, 2, 3, 3, 4, 4, 6]
						__UpperCamelCase    		=       [1, 3, 2, 0, 1, 4, 5, 6, 5]
						__UpperCamelCase    		=       [(u, v) for u, v in zip(source, target)]
						__UpperCamelCase    		=       create_graph(n_vertices, edges)

						assert [[5], [6], [4], [3, 2, 1, 0]] == tarjan(g)


