





def    _A	(   lowerCamelCase ):  # noqa: E741
   a__						:    Tuple   		=	len(_UpperCamelCase )
   a__						:    str   		=	0
   a__						:    Dict   		=	[0] * n
   a__						:    List[Any]   		=	[False] * n
   a__						:    Optional[Any]   		=	[False] * n

   def dfs(lowerCamelCase				,			lowerCamelCase				,			lowerCamelCase				,			lowerCamelCase ):
      if parent == root:
         out_edge_count += 1
      a__						:    List[Any]   		=	True
      a__						:    List[Any]   		=	at

      for to in l[at]:
         if to == parent:
            pass
         elif not visited[to]:
            a__						:    List[str]   		=	dfs(_UpperCamelCase				,			_UpperCamelCase				,			_UpperCamelCase				,			_UpperCamelCase )
            a__						:    Optional[Any]   		=	min(low[at]				,			low[to] )

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

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

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


# Adjacency list of graph
SCREAMING_SNAKE_CASE__							:      Union[str, 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 typing import Any

class   _a							:






     def __init__(					self   ,_SCREAMING_SNAKE_CASE       )				->     List[str]:
          _snake_case				= data
          _snake_case				= None







class   _a							:






     def __init__(					self       )				->     List[Any]:
          _snake_case				= None






     def 							_lowercase      (					self       )				->     str:
          _snake_case				= self.head
          while temp is not None:
               print(temp.data   ,end=" "       )
               _snake_case				= temp.next
          print()






     def 							_lowercase      (					self   ,_SCREAMING_SNAKE_CASE       )				->     Dict:
          _snake_case				= Node(_SCREAMING_SNAKE_CASE       )
          _snake_case				= self.head
          _snake_case				= new_node






     def 							_lowercase      (					self   ,_SCREAMING_SNAKE_CASE   ,_SCREAMING_SNAKE_CASE       )				->     Tuple:
          if node_data_a == node_data_a:
               return
          else:
               _snake_case				= self.head
               while node_a is not None and node_a.data != node_data_a:
                    _snake_case				= node_a.next

               _snake_case				= self.head
               while node_a is not None and node_a.data != node_data_a:
                    _snake_case				= node_a.next

               if node_a is None or node_a is None:
                    return

               _snake_case				,   _snake_case				= node_a.data, node_a.data


if __name__ == "__main__":
   UpperCamelCase_		:     str          =		LinkedList()
   for i in range(5, 0, -1):
      ll.push(i)

   ll.print_list()

   ll.swap_nodes(1, 4)
   print('''After swapping''')
   ll.print_list()


