anchor.diff:  do_solve(DepGraph0, RawGoals, Timeout) ->
       Goals = [fix_con(Goal) || Goal <- RawGoals],
   case lists:filter(fun (Goal) ->
  -		PkgName = dep_pkg(Goal),
  -		contains_package_version(DepGraph0, PkgName) == false
  -	end,
  -	Goals) of
  -	[] ->
  -	  Self = self(),
  -	  F = fun() ->
  +        PkgName = dep_pkg(Goal),
  +        contains_package_version(DepGraph0, PkgName) == false
  +    end,
  +    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),
  -	receive
  -	  Result ->
  -		Result
  -	after Timeout ->
  -		exit(Pid, kill),
  -		{error, resolution_timeout}
  -	end;
  -	[MissingPackage | _] ->
  -	  {error, {unreachable_package, dep_pkg(MissingPackage)}}
  +            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),
  +    receive
  +      Result ->
  +        Result
  +    after Timeout ->
  +        exit(Pid, kill),
  +        {error, resolution_timeout}
  +    end;
  +    [MissingPackage | _] ->
  +      {error, {unreachable_package, dep_pkg(MissingPackage)}}
     end.
   
   %% Parse a string version into a tuple based version
  
positive.code:                 NewVisited = [{Pkg, Vsn} | Visited],
                  Res = all_pkgs(DepGraph, NewVisited, DepPkgs ++ OtherPkgs, UConstraints, PathInd),
                  Res
  			end,
  			  case constrained_package_versions(DepGraph, Pkg, Constraints) of
  				[] ->
  				  {fail, [{Visited, Constraints}]};
  				missing ->
  				  {missing, Pkg};
  				Res ->
  				  lists_some(F, Res, PathInd)
  			  end.
  
  
  %% @doc This gathers the dependency constraints for a given package vsn from the
  
negative.code:                              [pkg()] | fail_detail().
  primitive_solve(State, PackageList, PathInd)
    when erlang:length(PackageList) > 0 ->
        Constraints = lists:foldl(fun(Info, Acc) ->
                                          add_constraint('_GOAL_', 'NO_VSN', Acc, Info)
                                  end, new_constraints(), PackageList),
  
        Pkgs = lists:map(fun dep_pkg/1, PackageList),
        all_pkgs(State, [], Pkgs, Constraints, PathInd).
  
  
  %% @doc
  