






def _UpperCAmelCase   (	a						:	Any ):  # noqa: E741
							snake_case__	  =       len(a )
							snake_case__	  =       0
							snake_case__	  =       [0] * n
							snake_case__	  =       [False] * n
							snake_case__	  =       [False] * n

							def dfs(a						:	str  ,					a						:	Any  ,					a						:	int  ,					a						:	int ):
														if parent == root:
																					out_edge_count += 1
														snake_case__	  =       True
														snake_case__	  =       at

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

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

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

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


# Adjacency list of graph
a__       =     {
    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)








from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


a__       =     {
    """configuration_autoformer""": [
        """AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """AutoformerConfig""",
    ],
}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	a__       =     [
	    """AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
	    """AutoformerForPrediction""",
	    """AutoformerModel""",
	    """AutoformerPreTrainedModel""",
	]


if TYPE_CHECKING:
	from .configuration_autoformer import (
	    AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
	    AutoformerConfig,
	)

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_autoformer import (
		    AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
		    AutoformerForPrediction,
		    AutoformerModel,
		    AutoformerPreTrainedModel,
		)

else:
	import sys

	a__       =     _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
