rem: std::cerr << "  (" << source.get_package().get_name() << " " << source.get_name() << " is not installed)" << std::endl;
add: std::cerr << "  (" << (*si).get_package().get_name() << " " << (*si).get_name() << " is installed)" << std::endl;
context:   void process_solution(const solution &s)  {    // Any forcings are immediately applied to 'curr', so that    // forcings are performed ASAP.    solution curr = s;    eassert(!s.get_broken().empty());    // This loop attempts to generate all the successors of a    // solution.  However, if a "forced" dependency arises, it    // re-verifies all the dependencies of the solution.    bool done = false;    while(!done)      {	if(debug)	  {	    std::cout << "Processing ";	    curr.dump(std::cout);	    std::cout << std::endl;	  }	done = true;	// Remember the solution whose broken dependencies we're	// iterating over.	solution starting_solution = curr;	for(typename imm::set<dep>::const_iterator bi=starting_solution.get_broken().begin();	    bi!=starting_solution.get_broken().end(); ++bi)	  {	    // Check for the case where this dependency has been	    // fortuitously solved by forcing another broken	    // dependency.	    if(starting_solution != curr && !(*bi).broken_under(curr))	      continue;	    // Assert against impossible conditions (if this happens	    // something is broken elsewhere).	    if(starting_solution == curr && !(*bi).broken_under(curr))	      {		std::cerr << "Unexpectedly non-broken dependency "			  << *bi << "!" << std::endl;		version source = (*bi).get_source();		if(curr.version_of(source.get_package()) != source)		  std::cerr << "  (" << source.get_package().get_name()			    << " " << source.get_name()			    << " is not installed)" << std::endl;		for(typename dep::solver_iterator si = (*bi).solvers_begin();		    !si.end(); ++si)		  if(curr.version_of((*si).get_package()) == *si)		    std::cerr << "  (" << source.get_package().get_name()			      << " " << source.get_name()			      << " is not installed)" << std::endl;		abort();	      }	    imm::map<package, action> conflict;	    int num_successors = 0;	    generate_successors(curr, *bi, conflict,				null_generator(num_successors));	    if(num_successors == 0)	      {		if(debug)		  {		    std::cout << "Discarding solution; unresolvable dependency "			      << *bi << " with conflict ";		    dump_conflict(std::cout, conflict);		    std::cout << std::endl;		  }		add_conflict(conflict);		return;	      }	    else if(num_successors == 1)	      {		if(debug)		  std::cout << "Forced resolution of " << *bi << std::endl;		std::vector<solution> v;		real_generator g(v);		// NB: this may do redundant work adding to 'conflict'.		// Use a generator object to avoid that?		generate_successors(curr, *bi, conflict,				    real_generator(v));		eassert(v.size() == 1);		curr = v.back();		done = false;	      }	  }      }    // In the course of forcing dependencies, we might have actually    // arrived at a solution, in which case we should just enqueue it    // and stop (a full solution has no successors to generate).    if(curr.is_full_solution())      {	try_enqueue(curr);	return;      }    unsigned int nsols = 0;    // First try to enqueue stuff related to a dependency that the    // user constrained; then just go for a free-for-all.    for(typename imm::set<dep>::const_iterator bi=curr.get_broken().begin();	bi!=curr.get_broken().end() && (nsols == 0 ||					nsols < max_successors); ++bi)      if(impinges_user_constraint(*bi))	{	  // Is it possible to take this out somehow?	  imm::map<package, action> conflict;	  if(debug)	    std::cout << "Generating successors for " << *bi		      << std::endl;	  std::vector<solution> v;	  generate_successors(curr, *bi, conflict, real_generator(v));	  try_enqueue(v);	  nsols += v.size();	}    for(typename imm::set<dep>::const_iterator bi=curr.get_broken().begin();	bi!=curr.get_broken().end() && (nsols == 0 ||					nsols < max_successors); ++bi)      {	// Is it possible to take this out somehow?	imm::map<package, action> conflict;	if(debug)	  std::cout << "Generating successors for " << *bi		    << std::endl;	std::vector<solution> v;	generate_successors(curr, *bi, conflict, real_generator(v));	try_enqueue(v);	nsols += v.size();      }  }