


def   _UpperCAmelCase       (     UpperCAmelCase      :			Optional[int]      ):  # noqa: E741
      """simple docstring"""




      __lowerCamelCase     :      Tuple       						=						len(lowerCAmelCase__      )
      __lowerCamelCase     :      Optional[int]       						=						0
      __lowerCamelCase     :      Optional[int]       						=						[0] * n
      __lowerCamelCase     :      Any       						=						[False] * n
      __lowerCamelCase     :      List[str]       						=						[False] * n

      def dfs(UpperCAmelCase      :			Tuple						,	UpperCAmelCase      :			Optional[Any]						,	UpperCAmelCase      :			List[str]						,	UpperCAmelCase      :			Union[str, Any]      ):
            if parent == root:
                  out_edge_count += 1
            __lowerCamelCase     :      Optional[int]       						=						True
            __lowerCamelCase     :      Dict       						=						at

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

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

      for i in range(lowerCAmelCase__      ):
            if not visited[i]:
                  __lowerCamelCase     :      Tuple       						=						0
                  __lowerCamelCase     :      Optional[Any]       						=						dfs(lowerCAmelCase__						,	lowerCAmelCase__						,	-1						,	lowerCAmelCase__      )
                  __lowerCamelCase     :      int       						=						out_edge_count > 1

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


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







def   _UpperCAmelCase       (     UpperCAmelCase      :			list      ):
      """simple docstring"""




      __lowerCamelCase     :      Optional[int]       						=						len(UpperCAmelCase      )
      for _ in range(UpperCAmelCase      ):
            for i in range(_ % 2						,	arr_size - 1						,	2      ):
                  if arr[i + 1] < arr[i]:
                        __lowerCamelCase						, __lowerCamelCase     :      List[str]       						=						arr[i + 1], arr[i]

      return arr


if __name__ == "__main__":
    __UpperCamelCase    :						str     =							list(range(10, 0, -1))
    print(F'''Original: {arr}. Sorted: {odd_even_transposition(arr)}''')



