





"""simple docstring"""
import inspect
import os
import sys
import unittest

import accelerate
from accelerate.test_utils import execute_subprocess_async, require_tpu
class lowerCamelCase__	(     unittest.TestCase					):



   def  _UpperCAmelCase						(							self						)			->     Dict:







      """simple docstring"""
      lowercase     :      int	=							inspect.getfile(accelerate.test_utils						)
      lowercase     :      str	=							os.path.sep.join(mod_file.split(os.path.sep						)[:-1] + ["""scripts""", """test_script.py"""]						)
      lowercase     :      Dict	=							os.path.sep.join(inspect.getfile(self.__class__						).split(os.path.sep						)[:-1]						)





   @require_tpu
   def  _UpperCAmelCase						(							self						)			->     Optional[Any]:







      """simple docstring"""
      lowercase     :      List[Any]	=							f'''
            {self.test_dir}/xla_spawn.py
            --num_cores 8
            {self.test_file_path}
        '''.split()
      lowercase     :      int	=							[sys.executable] + distributed_args
      execute_subprocess_async(A_   , env=os.environ.copy()						)






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)





