anchor.diff:  	       true -> t_fun(t_fun_args(T), t_unit())
   	     end || T <- NewTypes],
   	  Map3 = enter_type_lists(Funs, UnitTypes, Map2),
  -	  solve_scc(SCC, Map3, State, true);
  +	  solve_scc(SCC, Parallel, Map3, State, true);
   	false ->
  +	  case Parallel of
  +	    false -> true;
  +	    _ -> dispose_state(State)
  +	  end,
   	  Map2
         end;
       false ->
         ?debug("SCC ~w did not reach fixpoint\n", [SCC]),
  -      solve_scc(SCC, Map2, State, TryingUnit)
  -  end.
  +      solve_scc(SCC, Parallel, Map2, State, TryingUnit)
  +  end.
  +
  +solve_whole_scc(SCC, Map, State) ->
  +  SolveFun = fun(X, Y) -> scc_fold_fun(X, Y, State) end,
  +  lists:foldl(SolveFun, Map, SCC).
  +
  +%%------------------------------------------------------------------------------
  +
  +-define(worth_it, 42).
  +
  +parallel_split(SCC) ->
  +  Length = length(SCC),
  +  case Length > 2*?worth_it of
  +    false -> false;
  +    true ->
  +      case min(erlang:system_info(logical_processors_available), 8) of
  +	1 -> false;
  +	CPUs ->
  +	  FullShare = Length div CPUs + 1,
  +	  Unit = max(FullShare, ?worth_it),
  +	  split(SCC, Unit, [])
  +      end
  +  end.
  +
  +minimize_state(#state{
  +		  cmap        = {d, CMap},
  +		  fun_map     = FunMap,
  +		  fun_arities = FunArities,
  +		  self_rec    = SelfRec,
  +		  prop_types  = {d, PropTypes},
  +		  opaques     = Opaques
  +		 }) ->
  +  ETSCMap = ets:new(cmap,[{read_concurrency, true}]),
  +  ETSPropTypes = ets:new(prop_types,[{read_concurrency, true}]),
  +  true = ets:insert(ETSCMap, dict:to_list(CMap)),
  +  true = ets:insert(ETSPropTypes, dict:to_list(PropTypes)),
  +  #state
  +    {cmap        = {e, ETSCMap},
  +     fun_map     = FunMap,
  +     fun_arities = FunArities,
  +     self_rec    = SelfRec,
  +     prop_types  = {e, ETSPropTypes},
  +     opaques     = Opaques
  +    }.
  +
  +dispose_state(#state{cmap = {e, ETSCMap},
  +		     prop_types = {e, ETSPropTypes}}) ->
  +  true = ets:delete(ETSCMap),
  +  true = ets:delete(ETSPropTypes).
  +
  +solve_whole_scc_parallel(SplitSCC, Map, State) ->
  +  Workers = spawn_workers(SplitSCC, Map, State),
  +  wait_results(Workers, Map, fold_res_fun(State)).
  +
  +spawn_workers(SplitSCC, Map, State) ->
  +  Spawner = solve_scc_spawner(self(), Map, State),
  +  lists:foreach(Spawner, SplitSCC),
  +  length(SplitSCC).
  +
  +wait_results(0, Map, _FoldResFun) ->
  +  Map;
  +wait_results(Pending, Map, FoldResFun) ->
  +  Res = receive_scc_result(),
  +  NewMap = lists:foldl(FoldResFun, Map, Res),
  +  wait_results(Pending-1, NewMap, FoldResFun).
  +
  +solve_scc_spawner(Parent, Map, State) ->
  +  fun(SCCPart) ->
  +      spawn_link(fun() -> solve_scc_worker(Parent, SCCPart, Map, State) end)
  +  end.
  +
  +split([], _Unit, Acc) ->
  +  Acc;
  +split(List, Unit, Acc) ->
  +  {Taken, Rest} =
  +    try
  +      lists:split(Unit, List)
  +    catch
  +      _:_ -> {List, []}
  +    end,
  +  split(Rest, Unit, [Taken|Acc]).
  +
  +solve_scc_worker(Parent, SCCPart, Map, State) ->
  +  SolveFun = fun(X, Y) -> scc_fold_fun(X, Y, State) end,
  +  FinalMap = lists:foldl(SolveFun, Map, SCCPart),
  +  Res =
  +    [{F, t_limit(unsafe_lookup_type(F, FinalMap), ?TYPE_LIMIT)} ||
  +      F <- SCCPart],
  +  send_scc_result(Parent, Res).
  +
  +fold_res_fun(State) ->
  +  fun({F, Type}, Map) ->
  +      case state__get_rec_var(F, State) of
  +	{ok, R} ->
  +	  enter_type(R, Type, enter_type(F, Type, Map));
  +	error ->
  +	  enter_type(F, Type, Map)
  +      end
  +  end.
  +
  +receive_scc_result() ->
  +    receive
  +      {scc_fun, Res} -> Res
  +    end.
  +
  +send_scc_result(Parent, Res) ->
  +  Parent ! {scc_fun, Res}.
  +
  +%%------------------------------------------------------------------------------
   
   scc_fold_fun(F, FunMap, State) ->
     Deps = get_deps(state__get_cs(F, State)),
  
positive.code:   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) ->
    NewDict = dict:store(Id, Cs, Dict),
    State#state{cmap = NewDict}.
  
  state__get_cs(Var, #state{cmap = 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__store_funs(Vars0, Funs0, #state{fun_map = Map} = State) ->
    debug_make_name_map(Vars0, Funs0),
  
negative.code: 	       end,
    enter_type(Fun, NewType, NewFunMap1).
  
  solve_scc(SCC, Parallel, Map, State, TryingUnit) ->
    Vars0 = [{Fun, state__get_rec_var(Fun, State)} || Fun <- SCC],
    Vars = [Var || {_, {ok, Var}} <- Vars0],
    Funs = [Fun || {Fun, {ok, _}} <- Vars0],
  