


A	:		Optional[Any]    =       tuple[float, float, float]
A	:		str    =       tuple[float, float, float]






def 			UpperCamelCase (     __magic_name__					:							Pointad   ,   __magic_name__					:							Pointad					)       ->  Vectorad:
		"""simple docstring"""




		lowercase__					      =		end_pointa[0] - end_pointa[0]
		lowercase__					      =		end_pointa[1] - end_pointa[1]
		lowercase__					      =		end_pointa[2] - end_pointa[2]
		return (x, y, z)






def 			UpperCamelCase (     __magic_name__					:							Vectorad   ,   __magic_name__					:							Vectorad					)       ->  Vectorad:
		"""simple docstring"""




		lowercase__					      =		ab[1] * ac[2] - ab[2] * ac[1]  # *i
		lowercase__					      =		(ab[0] * ac[2] - ab[2] * ac[0]) * -1  # *j
		lowercase__					      =		ab[0] * ac[1] - ab[1] * ac[0]  # *k
		return (x, y, z)






def 			UpperCamelCase (     __magic_name__					:							Vectorad   ,   __magic_name__					:							int					)       ->  bool:
		"""simple docstring"""




		return tuple(round(_UpperCAmelCase   ,   _UpperCAmelCase					) for x in vector					) == (0, 0, 0)







def 			UpperCamelCase (     __magic_name__					:							Pointad   ,   __magic_name__					:							Pointad   ,   __magic_name__					:							Pointad   ,   __magic_name__					:							int = 10					)       ->  bool:
		"""simple docstring"""




		lowercase__					      =		create_vector(_UpperCAmelCase   ,   _UpperCAmelCase					)
		lowercase__					      =		create_vector(_UpperCAmelCase   ,   _UpperCAmelCase					)
		return is_zero_vector(get_ad_vectors_cross(_UpperCAmelCase   ,   _UpperCAmelCase					)   ,   _UpperCAmelCase					)





def 			UpperCamelCase (     __magic_name__					:							str					)       ->  List[str]:  # noqa: E741
		"""simple docstring"""




		lowercase__					      =		len(__magic_name__					)
		lowercase__					      =		0
		lowercase__					      =		[0] * n
		lowercase__					      =		[False] * n
		lowercase__					      =		[False] * n

		def dfs(__magic_name__					:							str   ,   __magic_name__					:							List[str]   ,   __magic_name__					:							str   ,   __magic_name__					:							Any					):
				if parent == root:
						out_edge_count += 1
				lowercase__					      =		True
				lowercase__					      =		at

				for to in l[at]:
						if to == parent:
								pass
						elif not visited[to]:
								lowercase__					      =		dfs(__magic_name__   ,   __magic_name__   ,   __magic_name__   ,   __magic_name__					)
								lowercase__					      =		min(low[at]   ,   low[to]					)

								# AP found via bridge
								if at < low[to]:
										lowercase__					      =		True
								# AP found via cycle
								if at == low[to]:
										lowercase__					      =		True
						else:
								lowercase__					      =		min(low[at]   ,   __magic_name__					)
				return out_edge_count

		for i in range(__magic_name__					):
				if not visited[i]:
						lowercase__					      =		0
						lowercase__					      =		dfs(__magic_name__   ,   __magic_name__   ,   -1   ,   __magic_name__					)
						lowercase__					      =		out_edge_count > 1

		for x in range(len(__magic_name__					)					):
				if is_art[x] is True:
						print(__magic_name__					)


# Adjacency list of graph
A	:		List[str]    =       {
    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],
}







compute_ap(data)

