





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

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_speech_available,
    is_tf_available,
    is_torch_available,
)


lowerCAmelCase:						Tuple				   ={
    'configuration_speech_to_text': ['SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'Speech2TextConfig'],
    'processing_speech_to_text': ['Speech2TextProcessor'],
}

try:
   if not is_sentencepiece_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowerCAmelCase:						Tuple				   =['Speech2TextTokenizer']

try:
   if not is_speech_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowerCAmelCase:						List[Any]				   =['Speech2TextFeatureExtractor']

try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowerCAmelCase:						int				   =[
       'TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST',
       'TFSpeech2TextForConditionalGeneration',
       'TFSpeech2TextModel',
       'TFSpeech2TextPreTrainedModel',
   ]

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowerCAmelCase:						Any				   =[
       'SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST',
       'Speech2TextForConditionalGeneration',
       'Speech2TextModel',
       'Speech2TextPreTrainedModel',
   ]


if TYPE_CHECKING:
   from .configuration_speech_to_text import SPEECH_TO_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, SpeechaTextConfig
   from .processing_speech_to_text import SpeechaTextProcessor

   try:
      if not is_sentencepiece_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .tokenization_speech_to_text import SpeechaTextTokenizer

   try:
      if not is_speech_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .feature_extraction_speech_to_text import SpeechaTextFeatureExtractor

   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_speech_to_text import (
          TF_SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFSpeechaTextForConditionalGeneration,
          TFSpeechaTextModel,
          TFSpeechaTextPreTrainedModel,
      )

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_speech_to_text import (
          SPEECH_TO_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
          SpeechaTextForConditionalGeneration,
          SpeechaTextModel,
          SpeechaTextPreTrainedModel,
      )

else:
   import sys

   lowerCAmelCase:						Any				   =_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)






def    a__    (		snake_case__					:							Tuple     ):  # noqa: E741
  _UpperCAmelCase		:							Dict							=     len(snake_case__     )
  _UpperCAmelCase		:							Tuple							=     0
  _UpperCAmelCase		:							Union[str, Any]							=     [0] * n
  _UpperCAmelCase		:							Union[str, Any]							=     [False] * n
  _UpperCAmelCase		:							Tuple							=     [False] * n

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

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

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

  for i in range(snake_case__     ):
    if not visited[i]:
      _UpperCAmelCase		:							List[Any]							=     0
      _UpperCAmelCase		:							List[str]							=     dfs(snake_case__						,   snake_case__						,   -1						,   snake_case__     )
      _UpperCAmelCase		:							Optional[Any]							=     out_edge_count > 1

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


# Adjacency list of graph
SCREAMING_SNAKE_CASE__					:     Optional[Any]       =     {
    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)





