anchor.diff:    Vars = [t_var(X) || X <- lists:seq(NL, NewLabel-1)],
     {State#state{next_label = NewLabel}, Vars}.
   
  -state__store_constrs(Id, Cs, #state{cmap = Dict} = State) ->
  +state__store_constrs(Id, Cs, #state{cmap = {d, Dict}} = State) ->
     NewDict = dict:store(Id, Cs, Dict),
  -  State#state{cmap = NewDict}.
  -
  -state__get_cs(Var, #state{cmap = Dict}) ->
  +  State#state{cmap = {d, NewDict}}.
  +
  +state__get_cs(Var, #state{cmap = {e, ETSDict}}) ->
  +  ets:lookup_element(ETSDict, Var, 2);
  +state__get_cs(Var, #state{cmap = {d, Dict}}) ->
     dict:fetch(Var, Dict).
   
  -%% The functions here will not be treated as self recursive.
  -%% These functions will need to be handled as such manually.
  -state__mark_as_non_self_rec(SCC, #state{self_recs = SelfRecs} = State) ->
  -  %% TODO: Check if the result is always empty and just set it to [] if so.
  -  State#state{self_recs = ordsets:subtract(SelfRecs, ordsets:from_list(SCC))}.
  -
  -state__is_self_rec(Fun, #state{self_recs = SelfRecs}) ->
  -  ordsets:is_element(Fun, SelfRecs).
  +state__is_self_rec(Fun, #state{self_rec = SelfRec}) ->
  +  Fun =:= SelfRec.
   
   state__store_funs(Vars0, Funs0, #state{fun_map = Map} = State) ->
     debug_make_name_map(Vars0, Funs0),
  
positive.code:   NameMap = dict:from_list(List),
    MFAs = [MFA || {MFA, _Var} <- List],
    SCC = [mk_var(Fun) || {_MFA, {_Var, Fun}, _Rec} <- SCC0],
    SelfRecs = [F || F <- SCC,
  		   dialyzer_callgraph:is_self_rec(t_var_name(F), CallGraph)],
    #state{callgraph = CallGraph, name_map = NameMap, next_label = NextLabel,
  	 prop_types = PropTypes, plt = Plt, scc = ordsets:from_list(SCC),
  	 mfas = MFAs, self_recs = ordsets:from_list(SelfRecs)}.
  
  state__set_rec_dict(State, RecDict) ->
    State#state{records = RecDict}.
  
negative.code: solve([_|_] = SCC, State) ->
    ?debug("============ Analyzing SCC: ~w ===========\n",
  	 [[debug_lookup_name(F) || F <- SCC]]),
    {Parallel, NewState} =
      case parallel_split(SCC) of
        false -> {false, State};
        SplitSCC -> {SplitSCC, minimize_state(State)}
      end,
    solve_scc(SCC, Parallel, dict:new(), NewState, false).
  
  solve_fun(Fun, FunMap, State) ->
    Cs = state__get_cs(Fun, State),
  