





def 						lowerCamelCase__     (     UpperCamelCase__			:       Any						)			-> List[Any]:



					'''simple docstring'''




					return [
					    {
					        0: [1, 2],
					        1: [0, 2],
					        2: [0, 1, 3, 5],
					        3: [2, 4],
					        4: [3],
					        5: [2, 6, 8],
					        6: [5, 7],
					        7: [6, 8],
					        8: [5, 7],
					    },
					    {
					        0: [6],
					        1: [9],
					        2: [4, 5],
					        3: [4],
					        4: [2, 3],
					        5: [2],
					        6: [0, 7],
					        7: [6],
					        8: [],
					        9: [1],
					    },
					    {
					        0: [4],
					        1: [6],
					        2: [],
					        3: [5, 6, 7],
					        4: [0, 6],
					        5: [3, 8, 9],
					        6: [1, 3, 4, 7],
					        7: [3, 6, 8, 9],
					        8: [5, 7],
					        9: [5, 7],
					    },
					    {
					        0: [1, 3],
					        1: [0, 2, 4],
					        2: [1, 3, 4],
					        3: [0, 2, 4],
					        4: [1, 2, 3],
					    },
					][index]





def 						lowerCamelCase__     (     UpperCamelCase__			:       dict[int, list[int]]						)			-> list[tuple[int, int]]:



					'''simple docstring'''




					_snake_case									=				0
					_snake_case									=				len(UpperCamelCase__						)  # No of vertices in graph
					_snake_case									=				[0] * n
					_snake_case									=				[False] * n

					def dfs(UpperCamelCase__			:       Union[str, Any]       ,    UpperCamelCase__			:       Tuple       ,    UpperCamelCase__			:       int       ,    UpperCamelCase__			:       Tuple						):
										_snake_case									=				True
										_snake_case									=				id_
										id_ += 1
										for to in graph[at]:
															if to == parent:
																				pass
															elif not visited[to]:
																				dfs(UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__       ,    id_						)
																				_snake_case									=				min(low[at]       ,    low[to]						)
																				if id_ <= low[to]:
																									bridges.append((at, to) if at < to else (to, at)						)
															else:
																				# This edge is a back edge and cannot be a bridge
																				_snake_case									=				min(low[at]       ,    low[to]						)

					_snake_case									=				[]
					for i in range(UpperCamelCase__						):
										if not visited[i]:
															dfs(UpperCamelCase__       ,    -1       ,    UpperCamelCase__       ,    id_						)
					return bridges


if __name__ == "__main__":
					import doctest

					doctest.testmod()










def 						lowerCamelCase__     (     UpperCamelCase__			:       list[int]       ,    UpperCamelCase__			:       int						)			-> bool:



					'''simple docstring'''




					_snake_case									=				len(UpperCamelCase__						)
					_snake_case									=				[[False] * (required_sum + 1) for _ in range(arr_len + 1						)]

					# for each arr value, a sum of zero(0) can be formed by not taking any element
					# hence True/1
					for i in range(arr_len + 1						):
										_snake_case									=				True

					# sum is not zero and set is empty then false
					for i in range(1       ,    required_sum + 1						):
										_snake_case									=				False

					for i in range(1       ,    arr_len + 1						):
										for j in range(1       ,    required_sum + 1						):
															if arr[i - 1] > j:
																				_snake_case									=				subset[i - 1][j]
															if arr[i - 1] <= j:
																				_snake_case									=				subset[i - 1][j] or subset[i - 1][j - arr[i - 1]]

					return subset[arr_len][required_sum]


if __name__ == "__main__":
					import doctest

					doctest.testmod()



