anchor.diff:  solve(DepGraph0, RawGoals, Timeout)
     when erlang:length(RawGoals) > 0 ->
       Goals = [fix_con(Goal) || Goal <- RawGoals],
  -    case lists:filter(fun (Goal) ->
  -                    PkgName = dep_pkg(Goal),
  -                    contains_package_version(DepGraph0, PkgName) == false
  -            end,
  -            Goals) of
  +    case find_unreachable_goals(DepGraph0, Goals) of
           [] ->
  -            Self = self(),
  -            F = fun() ->
  -                    case trim_unreachable_packages(DepGraph0, Goals) of
  -                        Error = {error, _} ->
  -                            Error;
  -                        DepGraph1 ->
  -                            case primitive_solve(DepGraph1, Goals, no_path) of
  -                                {fail, _} ->
  -                                    [FirstCons | Rest] = Goals,
  -                                    Self ! {error, depsolver_culprit:search(DepGraph1, [FirstCons], Rest)};
  -                                {missing, Pkg} ->
  -                                    Self ! {error, {unreachable_package, Pkg}};
  -                                Solution ->
  -                                    Self ! {ok, Solution}
  -                            end
  -                    end
  -            end,
  -            Pid = proc_lib:spawn(F),
  +			Pid = proc_lib:spawn(depsolver, do_solve, [DepGraph0, Goals, self()]),
               receive
                   Result ->
                       Result
  
positive.code: find_reachable_packages(_ExistingGraph, Error={error, _}, _PkgName) ->
      Error;
  find_reachable_packages(ExistingGraph, NewGraph0, PkgName) ->
      case contains_package_version(NewGraph0, PkgName) of
          true ->
              NewGraph0;
          false ->
              case gb_trees:lookup(PkgName, ExistingGraph) of
                  {value, Info} ->
                      NewGraph1 = gb_trees:insert(PkgName, Info, NewGraph0),
                      rewrite_vsns(ExistingGraph, NewGraph1, Info);
                  none ->
                    NewGraph1 = gb_trees:insert(PkgName, [{{missing},[]}],NewGraph0), %{error, {unreachable_package, PkgName}}
                      rewrite_vsns(ExistingGraph, NewGraph1, [{{missing},[]}])
              end
      end.
  
  %% @doc
  %%  Checks to see if a package name has been defined in the dependency graph
  -spec contains_package_version(dep_graph(), pkg_name()) -> boolean().
  contains_package_version(Dom0, PkgName) ->
      gb_trees:is_defined(PkgName, Dom0).
  
negative.code:       [{missing}] ->
          missing;
        Result ->
  		[ R || R <- Result, R =/= {missing} ]
      end.
  
  %% Given a list of constraints filter said list such that only fail (for things
  