human
Complete the below
@not_implemented_for('undirected')
def strongly_connected_components_recursive(G):

    ''''Generate nodes in strongly connected components of graph.
    Recursive version of algorithm.
    Parameters
    G : NetworkX Graph
    A directed graph.
    Returns
    comp : generator of sets
    A generator of sets of nodes, one for each strongly connected
    component of G.
    Raises
    NetworkXNotImplemented :
    If G is undirected.
    Examples
    Generate a sorted list of strongly connected components, largest first.
    >>> G = nx.cycle_graph(4, create_using=nx.DiGraph())
    >>> nx.add_cycle(G, [10, 11, 12])
    >>> [len(c) for c in sorted(nx.strongly_connected_components_recursive(G),
    ...                         key=len, reverse=True)]
    [4, 3]
    If you only want the largest component, it\'s more efficient to
    use max instead of sort.
    >>> largest = max(nx.strongly_connected_components_recursive(G), key=len)
    See Also
    connected_components
    Notes
    Uses Tarjan\'s algorithm[1]_ with Nuutila\'s modifications[2]_.
    References
    .. [1] Depth-first search and linear graph algorithms, R. Tarjan
    SIAM Journal of Computing 1(2):146-160, (1972).
    .. [2] On finding the strongly connected components in a directed graph.
    E. Nuutila and E. Soisalon-Soinen
    Information Processing Letters 49(1): 9-14, (1994)..'
    '''
assistant
#Here is the Python program you requested.
    def visit(v, cnt):
        root[v] = cnt
        visited[v] = cnt
        cnt += 1
        stack.append(v)
        for w in G[v]:
            if (w not in visited):
                for c in visit(w, cnt):
                    (yield c)
            if (w not in component):
                root[v] = min(root[v], root[w])
        if (root[v] == visited[v]):
            component[v] = root[v]
            tmpc = {v}
            while (stack[(-1)] != v):
                w = stack.pop()
                component[w] = root[v]
                tmpc.add(w)
            stack.remove(v)
            (yield tmpc)
    visited = {}
    component = {}
    root = {}
    cnt = 0
    stack = []
    for source in G:
        if (source not in visited):
            for c in visit(source, cnt):
                (yield c)