





from __future__ import annotations

from collections.abc import Iterable, Iterator
from dataclasses import dataclass

lowercase				:	List[Any]      						=  (3, 9, -1_1, 0, 7, 5, 1, -1)
lowercase				:	Tuple      						=  (4, 6, 2, 0, 8, 1_0, 3, -2)





@dataclass
class 			A__   :




			"""simple docstring"""



			__A       :    int	  =  4_2
			__A       :    List[str]	  =  4_2





class 			A__   :




			"""simple docstring"""



			def __init__( self ,  lowercase)      ->						Optional[Any]:







										'''simple docstring'''

										a__						:     Node | None			=    None
										for i in sorted(lowercase_ ,  reverse=lowercase_):
																	a__						:     Optional[int]			=    Node(lowercase_ ,  self.head)

			def __iter__( self)      ->						int:







										'''simple docstring'''

										a__						:     Tuple			=    self.head
										while node:
																	yield node.data
																	a__						:     str			=    node.next_node

			def __len__( self)      ->						Union[str, Any]:







										'''simple docstring'''

										return sum(1 for _ in self)

			def __str__( self)      ->						Tuple:







										'''simple docstring'''

										return " -> ".join([str(lowercase_) for node in self])



def A_     (		A__		,				A__    )  ->		SortedLinkedList:
							return SortedLinkedList(list(UpperCAmelCase__    ) + list(UpperCAmelCase__    )    )


if __name__ == "__main__":
				import doctest

				doctest.testmod()
				lowercase				:	List[str]      						=  SortedLinkedList
				print(merge_lists(SSL(test_data_odd), SSL(test_data_even)))









def A_     (		A__    )  ->		List[str]:  # noqa: E741
       a__						:     Dict			=    len(A__    )
       a__						:     str			=    0
       a__						:     Any			=    [0] * n
       a__						:     int			=    [False] * n
       a__						:     Optional[Any]			=    [False] * n

       def dfs(A__		,				A__		,				A__		,				A__    ):
              if parent == root:
                     out_edge_count += 1
              a__						:     Union[str, Any]			=    True
              a__						:     Optional[Any]			=    at

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

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

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

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


# Adjacency list of graph
lowercase				:	List[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)


