'''simple docstring'''

def snake_case_      (					__snake_case  :							Optional[Any])			->					Any:  # noqa: E741
   lowerCAmelCase_			=      len(__snake_case)
   lowerCAmelCase_			=      0
   lowerCAmelCase_			=      [0] * n
   lowerCAmelCase_			=      [False] * n
   lowerCAmelCase_			=      [False] * n

   def dfs(__snake_case  :							int	,   __snake_case  :							Optional[int]	,   __snake_case  :							str	,   __snake_case  :							Dict):
      if parent == root:
         out_edge_count += 1
      lowerCAmelCase_			=      True
      lowerCAmelCase_			=      at

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

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

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

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


# Adjacency list of graph
A_     :						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)






'''simple docstring'''

from __future__ import annotations



def snake_case_      (					__snake_case  :							list[int | str])			->					None:
   create_state_space_tree(__snake_case	,   []	,   0	,   [0 for i in range(len(__snake_case))])



def snake_case_      (					__snake_case  :							list[int | str]	,   __snake_case  :							list[int | str]	,   __snake_case  :							int	,   __snake_case  :							list[int]	,   )			->					None:

   if index == len(__snake_case):
      print(__snake_case)
      return

   for i in range(len(__snake_case)):
      if not index_used[i]:
         current_sequence.append(sequence[i])
         lowerCAmelCase_			=      True
         create_state_space_tree(__snake_case	,   __snake_case	,   index + 1	,   __snake_case)
         current_sequence.pop()
         lowerCAmelCase_			=      False
A_     :						list[int | str]    							=[3, 1, 2, 4]
generate_all_permutations(sequence)

A_     :						list[int | str]    							=["A", "B", "C"]






generate_all_permutations(sequence_a)





