






"""simple docstring"""






def       _A    (__a							)				-> Optional[int]:  # noqa: E741
    """simple docstring"""






    SCREAMING_SNAKE_CASE_   :						Optional[int]							=	len(__a							)
    SCREAMING_SNAKE_CASE_   :						str							=	0
    SCREAMING_SNAKE_CASE_   :						str							=	[0] * n
    SCREAMING_SNAKE_CASE_   :						str							=	[False] * n
    SCREAMING_SNAKE_CASE_   :						Union[str, Any]							=	[False] * n

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

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

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

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

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


# Adjacency list of graph
UpperCAmelCase_     :				List[str]         =				{
    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 math import isqrt



def       _A    (__a							)				-> list[int]:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_   :						Optional[Any]							=	[True] * max_number
    for i in range(2					,       isqrt(max_number - 1							) + 1							):
        if is_prime[i]:
            for j in range(i**2					,       __a					,       __a							):
                SCREAMING_SNAKE_CASE_   :						Tuple							=	False

    return [i for i in range(2					,       __a							) if is_prime[i]]



def       _A    (__a = 10**8							)				-> int:
    """simple docstring"""






    SCREAMING_SNAKE_CASE_   :						Any							=	calculate_prime_numbers(max_number // 2							)

    SCREAMING_SNAKE_CASE_   :						List[str]							=	0
    SCREAMING_SNAKE_CASE_   :						Any							=	0
    SCREAMING_SNAKE_CASE_   :						List[str]							=	len(__a							) - 1
    while left <= right:
        while prime_numbers[left] * prime_numbers[right] >= max_number:
            right -= 1
        semiprimes_count += right - left + 1
        left += 1

    return semiprimes_count


if __name__ == "__main__":
  print(f'''{solution() = }''')


