






'''simple docstring'''
def 	_a(					UpperCamelCase__			:  int							):  # noqa: E741




      '''simple docstring'''






      SCREAMING_SNAKE_CASE__       :			str													=len(UpperCamelCase__							)
      SCREAMING_SNAKE_CASE__       :			Dict													=0
      SCREAMING_SNAKE_CASE__       :			Union[str, Any]													=[0] * n
      SCREAMING_SNAKE_CASE__       :			Tuple													=[False] * n
      SCREAMING_SNAKE_CASE__       :			Tuple													=[False] * n

      def dfs(UpperCamelCase__			:  int,		UpperCamelCase__			:  str,		UpperCamelCase__			:  str,		UpperCamelCase__			:  List[str]							):
            if parent == root:
                  out_edge_count += 1
            SCREAMING_SNAKE_CASE__       :			Tuple													=True
            SCREAMING_SNAKE_CASE__       :			Optional[int]													=at

            for to in l[at]:
                  if to == parent:
                        pass
                  elif not visited[to]:
                        SCREAMING_SNAKE_CASE__       :			Tuple													=dfs(UpperCamelCase__,		UpperCamelCase__,		UpperCamelCase__,		UpperCamelCase__							)
                        SCREAMING_SNAKE_CASE__       :			Union[str, Any]													=min(low[at],		low[to]							)

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

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

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


# Adjacency list of graph
a_					=	{
    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 	_a(					UpperCamelCase__			:  List[str],		UpperCamelCase__			:  Union[str, Any],		UpperCamelCase__			:  int,		UpperCamelCase__			:  List[str]							):  # noqa: E741




      '''simple docstring'''






      while r - l > 1:
            SCREAMING_SNAKE_CASE__       :			List[str]													=(l + r) // 2
            if v[m] >= key:
                  SCREAMING_SNAKE_CASE__       :			Dict													=m
            else:
                  SCREAMING_SNAKE_CASE__       :			Any													=m  # noqa: E741
      return r





def 	_a(					UpperCamelCase__			:  list[int]							):




      '''simple docstring'''






      if len(UpperCamelCase__							) == 0:
            return 0

      SCREAMING_SNAKE_CASE__       :			List[Any]													=[0] * len(UpperCamelCase__							)
      SCREAMING_SNAKE_CASE__       :			Dict													=1

      SCREAMING_SNAKE_CASE__       :			Union[str, Any]													=v[0]

      for i in range(1,		len(UpperCamelCase__							)							):
            if v[i] < tail[0]:
                  SCREAMING_SNAKE_CASE__       :			List[Any]													=v[i]
            elif v[i] > tail[length - 1]:
                  SCREAMING_SNAKE_CASE__       :			int													=v[i]
                  length += 1
            else:
                  SCREAMING_SNAKE_CASE__       :			Union[str, Any]													=v[i]

      return length


if __name__ == "__main__":
  import doctest

  doctest.testmod()