




'''simple docstring'''







A									={0: [2, 3], 1: [0], 2: [1], 3: [4], 4: []}

A									={0: [1, 2, 3], 1: [2], 2: [0], 3: [4], 4: [5], 5: [3]}





def 		snake_case_							(_a			:							dict[int, list[int]]					,     _a			:							int					,     _a			:							list[bool]  ):
    UpperCAmelCase     =	True
    UpperCAmelCase     =	[]

    for neighbour in graph[vert]:
        if not visited[neighbour]:
            order += topology_sort(_a					,     _a					,     _a  )

    order.append(_a  )

    return order





def 		snake_case_							(_a			:							dict[int, list[int]]					,     _a			:							int					,     _a			:							list[bool]  ):
    UpperCAmelCase     =	True
    UpperCAmelCase     =	[vert]

    for neighbour in reversed_graph[vert]:
        if not visited[neighbour]:
            component += find_components(_a					,     _a					,     _a  )

    return component







def 		snake_case_							(_a			:							dict[int, list[int]]  ):
    UpperCAmelCase     =	len(_a  ) * [False]
    UpperCAmelCase     =	{vert: [] for vert in range(len(_a  )  )}

    for vert, neighbours in graph.items():
        for neighbour in neighbours:
            reversed_graph[neighbour].append(_a  )

    UpperCAmelCase     =	[]
    for i, was_visited in enumerate(_a  ):
        if not was_visited:
            order += topology_sort(_a					,     _a					,     _a  )

    UpperCAmelCase     =	[]
    UpperCAmelCase     =	len(_a  ) * [False]

    for i in range(len(_a  )  ):
        UpperCAmelCase     =	order[len(_a  ) - i - 1]
        if not visited[vert]:
            UpperCAmelCase     =	find_components(_a					,     _a					,     _a  )
            components_list.append(_a  )

    return components_list










'''simple docstring'''







def 		snake_case_							():
    for n in range(1					,     1_0_0_0_0_0_0  ):
        yield n * (n + 1) // 2





def 		snake_case_							(_a			:							Union[str, Any]  ):
    UpperCAmelCase     =	1
    UpperCAmelCase     =	2
    while i * i <= n:
        UpperCAmelCase     =	0
        while n % i == 0:
            n //= i
            multiplicity += 1
        divisors_count *= multiplicity + 1
        i += 1
    if n > 1:
        divisors_count *= 2
    return divisors_count





def 		snake_case_							():
    return next(i for i in triangle_number_generator() if count_divisors(_a  ) > 5_0_0  )


if __name__ == "__main__":
   print(solution())




