anchor.diff:  
   active_digraph_delete({'d', DG}) ->
     digraph:delete(DG);
  -active_digraph_delete({'e', Out, In}) ->
  +active_digraph_delete({'e', Out, In, Maps}) ->
     ets:delete(Out),
  -  ets:delete(In).
  +  ets:delete(In),
  +  ets:delete(Maps).
   
   digraph_edges(DG) ->
     digraph:edges(DG).
  
positive.code: 
  -spec get_depends_on(scc() | module(), callgraph()) -> [scc()].
  
  get_depends_on(SCC, #callgraph{active_digraph = {'e', Out, _In}}) ->
    case ets_lookup_dict(SCC, Out) of
      {ok, Value} -> Value;
      error -> []
    end;
  get_depends_on(SCC, #callgraph{active_digraph = {'d', DG}}) ->
    digraph:out_neighbours(DG, SCC).
  
  -spec get_required_by(scc() | module(), callgraph()) -> [scc()].
  
  get_required_by(SCC, #callgraph{active_digraph = {'e', _Out, In}}) ->
    case ets_lookup_dict(SCC, In) of
      {ok, Value} -> Value;
      error -> []
    end;
  get_required_by(SCC, #callgraph{active_digraph = {'d', DG}}) ->
    digraph:in_neighbours(DG, SCC).
  
  %%----------------------------------------------------------------------
  %% Handling of modules & SCCs
  
negative.code:   ok.
  
  condensation(G) ->
    SCCs = digraph_utils:strong_components(G),
    %% Assign unique numbers to SCCs:
    Ints = lists:seq(1, length(SCCs)),
    IntToSCC = lists:zip(Ints, SCCs),
    IntScc = sofs:relation(IntToSCC, [{int, scc}]),
    %% Subsitute strong components for vertices in edges using the
    %% unique numbers:
    C2V = sofs:relation([{SC, V} || SC <- SCCs, V <- SC], [{scc, v}]),
    I2V = sofs:relative_product(IntScc, C2V), % [{v, int}]
    Es = sofs:relation(digraph:edges(G), [{v, v}]),
    R1 = sofs:relative_product(I2V, Es),
    R2 = sofs:relative_product(I2V, sofs:converse(R1)),
    %% Create in- and out-neighbours:
    In = sofs:relation_to_family(sofs:strict_relation(R2)),
    R3 = sofs:converse(R2),
    Out = sofs:relation_to_family(sofs:strict_relation(R3)),
    [OutETS, InETS, MapsETS] =
      [ets:new(Name,[{read_concurrency, true}]) ||
        Name <- [callgraph_deps_out, callgraph_deps_in, callgraph_scc_map]],
    ets:insert(OutETS, sofs:to_external(Out)),
    ets:insert(InETS, sofs:to_external(In)),
    %% Create mappings from SCCs to unique integers, and the inverse:
    ets:insert(MapsETS, lists:zip([{'scc', SCC} || SCC<- SCCs], Ints)),
    ets:insert(MapsETS, IntToSCC),
    {{'e', OutETS, InETS, MapsETS}, SCCs}.
  