"""simple docstring"""
def 				lowerCAmelCase__      (     _UpperCamelCase    :			Union[str, Any]   )   ->			str:





						"""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    :			List[Any]	,     _UpperCamelCase    :			Optional[int]	,     _UpperCamelCase    :			List[str]	,     _UpperCamelCase    :			str   ):
												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()



"""simple docstring"""
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


SCREAMING_SNAKE_CASE__   =					{
    "configuration_data2vec_audio": ["DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP", "Data2VecAudioConfig"],
    "configuration_data2vec_text": [
        "DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "Data2VecTextConfig",
        "Data2VecTextOnnxConfig",
    ],
    "configuration_data2vec_vision": [
        "DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "Data2VecVisionConfig",
        "Data2VecVisionOnnxConfig",
    ],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					SCREAMING_SNAKE_CASE__   =					[
					    "DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "Data2VecAudioForAudioFrameClassification",
					    "Data2VecAudioForCTC",
					    "Data2VecAudioForSequenceClassification",
					    "Data2VecAudioForXVector",
					    "Data2VecAudioModel",
					    "Data2VecAudioPreTrainedModel",
					]
					SCREAMING_SNAKE_CASE__   =					[
					    "DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "Data2VecTextForCausalLM",
					    "Data2VecTextForMaskedLM",
					    "Data2VecTextForMultipleChoice",
					    "Data2VecTextForQuestionAnswering",
					    "Data2VecTextForSequenceClassification",
					    "Data2VecTextForTokenClassification",
					    "Data2VecTextModel",
					    "Data2VecTextPreTrainedModel",
					]
					SCREAMING_SNAKE_CASE__   =					[
					    "DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "Data2VecVisionForImageClassification",
					    "Data2VecVisionForMaskedImageModeling",
					    "Data2VecVisionForSemanticSegmentation",
					    "Data2VecVisionModel",
					    "Data2VecVisionPreTrainedModel",
					]

if is_tf_available():
					SCREAMING_SNAKE_CASE__   =					[
					    "TFData2VecVisionForImageClassification",
					    "TFData2VecVisionForSemanticSegmentation",
					    "TFData2VecVisionModel",
					    "TFData2VecVisionPreTrainedModel",
					]

if TYPE_CHECKING:
					from .configuration_dataavec_audio import DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP, DataaVecAudioConfig
					from .configuration_dataavec_text import (
					    DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP,
					    DataaVecTextConfig,
					    DataaVecTextOnnxConfig,
					)
					from .configuration_dataavec_vision import (
					    DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP,
					    DataaVecVisionConfig,
					    DataaVecVisionOnnxConfig,
					)

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_dataavec_audio import (
										    DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST,
										    DataaVecAudioForAudioFrameClassification,
										    DataaVecAudioForCTC,
										    DataaVecAudioForSequenceClassification,
										    DataaVecAudioForXVector,
										    DataaVecAudioModel,
										    DataaVecAudioPreTrainedModel,
										)
										from .modeling_dataavec_text import (
										    DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
										    DataaVecTextForCausalLM,
										    DataaVecTextForMaskedLM,
										    DataaVecTextForMultipleChoice,
										    DataaVecTextForQuestionAnswering,
										    DataaVecTextForSequenceClassification,
										    DataaVecTextForTokenClassification,
										    DataaVecTextModel,
										    DataaVecTextPreTrainedModel,
										)
										from .modeling_dataavec_vision import (
										    DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST,
										    DataaVecVisionForImageClassification,
										    DataaVecVisionForMaskedImageModeling,
										    DataaVecVisionForSemanticSegmentation,
										    DataaVecVisionModel,
										    DataaVecVisionPreTrainedModel,
										)
					if is_tf_available():
										from .modeling_tf_dataavec_vision import (
										    TFDataaVecVisionForImageClassification,
										    TFDataaVecVisionForSemanticSegmentation,
										    TFDataaVecVisionModel,
										    TFDataaVecVisionPreTrainedModel,
										)

else:
					import sys

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


