X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fsolver.c;h=efe3342820cebe263ddb031dd0f31bc660ec9424;hb=22e701e553344eeb22f88ed0906d76c9a5e39d83;hp=26a816155a18b4d426a0a1dfcd9e1b3a7479b0d7;hpb=a1052e73b2d754fc754294a25ac0bbd5ba35c1a3;p=platform%2Fupstream%2Flibsolv.git

diff --git a/src/solver.c b/src/solver.c
index 26a8161..efe3342 100644
--- a/src/solver.c
+++ b/src/solver.c
@@ -25,9 +25,12 @@
 #include "policy.h"
 #include "poolarch.h"
 #include "solverdebug.h"
+#include "cplxdeps.h"
+#include "linkedpkg.h"
 
 #define RULES_BLOCK 63
 
+
 /********************************************************************
  *
  * dependency check helpers
@@ -42,16 +45,34 @@
  * and is only true if pkg is installed and contains the specified path.
  * we also make sure that pkg is selected for an update, otherwise the
  * update would always be forced onto the user.
+ * Map m is the map used when called from dep_possible.
  */
+
+static int
+solver_is_updating(Solver *solv, Id p)
+{
+  /* check if the update rule is true */
+  Pool *pool = solv->pool;
+  Rule *r;
+  Id l, pp;
+  if (solv->decisionmap[p] >= 0)
+    return 0;	/* old package stayed */
+  r = solv->rules + solv->updaterules + (p - solv->installed->start);
+  FOR_RULELITERALS(l, pp, r)
+    if (l > 0 && l != p && solv->decisionmap[l] > 0)
+      return 1;
+  return 0;
+}
+
 int
-solver_splitprovides(Solver *solv, Id dep)
+solver_splitprovides(Solver *solv, Id dep, Map *m)
 {
   Pool *pool = solv->pool;
   Id p, pp;
   Reldep *rd;
   Solvable *s;
 
-  if (!solv->dosplitprovides || !solv->installed || (!solv->updatemap_all && !solv->updatemap.size))
+  if (!solv->dosplitprovides || !solv->installed)
     return 0;
   if (!ISRELDEP(dep))
     return 0;
@@ -74,101 +95,99 @@ solver_splitprovides(Solver *solv, Id dep)
       /* here we have packages that provide the correct name and contain the path,
        * now do extra filtering */
       s = pool->solvables + p;
-      if (s->repo == solv->installed && s->name == rd->name &&
-          (solv->updatemap_all || (solv->updatemap.size && MAPTST(&solv->updatemap, p - solv->installed->start))))
+      if (s->repo != solv->installed || s->name != rd->name)
+	continue;
+      /* check if the package is updated. if m is set, we're called from dep_possible */
+      if (m || solver_is_updating(solv, p))
 	return 1;
     }
   return 0;
 }
 
 
-/*-------------------------------------------------------------------
- * solver_dep_installed
- */
-
-int
-solver_dep_installed(Solver *solv, Id dep)
+/* mirrors solver_dep_fulfilled, but returns 2 if a new package
+ * was involved */
+static int
+solver_dep_fulfilled_alreadyinstalled(Solver *solv, Id dep)
 {
-#if 0
   Pool *pool = solv->pool;
   Id p, pp;
+  int r;
 
   if (ISRELDEP(dep))
     {
       Reldep *rd = GETRELDEP(pool, dep);
-      if (rd->flags == REL_AND)
+      if (rd->flags == REL_COND)
 	{
-	  if (!solver_dep_installed(solv, rd->name))
+	  int r1, r2;
+	  if (ISRELDEP(rd->evr))
+	    {
+	      Reldep *rd2 = GETRELDEP(pool, rd->evr);
+	      if (rd2->flags == REL_ELSE)
+		{
+		  r1 = solver_dep_fulfilled_alreadyinstalled(solv, rd2->name);
+		  if (r1)
+		    {
+		      r2 = solver_dep_fulfilled_alreadyinstalled(solv, rd->name);
+		      return r2 && r1 == 2 ? 2 : r2;
+		    }
+		  return solver_dep_fulfilled_alreadyinstalled(solv, rd2->evr);
+		}
+	    }
+	  r1 = solver_dep_fulfilled_alreadyinstalled(solv, rd->name);
+	  r2 = !solver_dep_fulfilled_alreadyinstalled(solv, rd->evr);
+	  if (!r1 && !r2)
 	    return 0;
-	  return solver_dep_installed(solv, rd->evr);
+          return r1 == 2 ? 2 : 1;
 	}
-      if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_INSTALLED)
-	return solver_dep_installed(solv, rd->evr);
-    }
-  FOR_PROVIDES(p, pp, dep)
-    {
-      if (p == SYSTEMSOLVABLE || (solv->installed && pool->solvables[p].repo == solv->installed))
-	return 1;
-    }
-#endif
-  return 0;
-}
-
-/* mirrors solver_dep_installed, but returns 2 if a
- * dependency listed in solv->installsuppdepq was involved */
-static int
-solver_check_installsuppdepq_dep(Solver *solv, Id dep)
-{
-  Pool *pool = solv->pool;
-  Id p, pp;
-  Queue *q;
-
-  if (ISRELDEP(dep))
-    {
-      Reldep *rd = GETRELDEP(pool, dep);
       if (rd->flags == REL_AND)
         {
-	  int r2, r1 = solver_check_installsuppdepq_dep(solv, rd->name);
+	  int r2, r1 = solver_dep_fulfilled_alreadyinstalled(solv, rd->name);
           if (!r1)
             return 0;
-	  r2 = solver_check_installsuppdepq_dep(solv, rd->evr);
+	  r2 = solver_dep_fulfilled_alreadyinstalled(solv, rd->evr);
 	  if (!r2)
 	    return 0;
           return r1 == 2 || r2 == 2 ? 2 : 1;
         }
       if (rd->flags == REL_OR)
 	{
-	  int r2, r1 = solver_check_installsuppdepq_dep(solv, rd->name);
-	  r2 = solver_check_installsuppdepq_dep(solv, rd->evr);
+	  int r2, r1 = solver_dep_fulfilled_alreadyinstalled(solv, rd->name);
+	  r2 = solver_dep_fulfilled_alreadyinstalled(solv, rd->evr);
 	  if (!r1 && !r2)
 	    return 0;
           return r1 == 2 || r2 == 2 ? 2 : 1;
 	}
       if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_SPLITPROVIDES)
-        return solver_splitprovides(solv, rd->evr);
-      if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_INSTALLED)
-        return solver_dep_installed(solv, rd->evr);
-      if (rd->flags == REL_NAMESPACE && (q = solv->installsuppdepq) != 0)
+        return solver_splitprovides(solv, rd->evr, 0);
+      if (rd->flags == REL_NAMESPACE && solv->installsuppdepq)
 	{
+	  Queue *q = solv->installsuppdepq;
 	  int i;
 	  for (i = 0; i < q->count; i++)
 	    if (q->elements[i] == dep || q->elements[i] == rd->name)
 	      return 2;
 	}
     }
+  r = 0;
   FOR_PROVIDES(p, pp, dep)
     if (solv->decisionmap[p] > 0)
-      return 1;
-  return 0;
+      {
+	Solvable *s = pool->solvables + p;
+	if (s->repo && s->repo != solv->installed)
+	  return 2;
+        r = 1;
+      }
+  return r;
 }
 
 static int
-solver_check_installsuppdepq(Solver *solv, Solvable *s)
+solver_is_supplementing_alreadyinstalled(Solver *solv, Solvable *s)
 {
   Id sup, *supp;
   supp = s->repo->idarraydata + s->supplements;
   while ((sup = *supp++) != 0)
-    if (solver_check_installsuppdepq_dep(solv, sup) == 2)
+    if (solver_dep_fulfilled_alreadyinstalled(solv, sup) == 2)
       return 1;
   return 0;
 }
@@ -181,27 +200,41 @@ autouninstall(Solver *solv, Id *problem)
   int lastfeature = 0, lastupdate = 0;
   Id v;
   Id extraflags = -1;
+  Map *m = 0;
 
+  if (!solv->allowuninstall && !solv->allowuninstall_all)
+    {
+      if (!solv->allowuninstallmap.size)
+	return 0;		/* why did we get called? */
+      m = &solv->allowuninstallmap;
+    }
   for (i = 0; (v = problem[i]) != 0; i++)
     {
       if (v < 0)
 	extraflags &= solv->job.elements[-v - 1];
-      if (v >= solv->featurerules && v < solv->featurerules_end)
-	if (v > lastfeature)
-	  lastfeature = v;
       if (v >= solv->updaterules && v < solv->updaterules_end)
 	{
-	  /* check if identical to feature rule */
-	  Id p = solv->rules[v].p;
 	  Rule *r;
-	  if (p <= 0)
+	  if (m && !MAPTST(m, v - solv->updaterules))
 	    continue;
-	  r = solv->rules + solv->featurerules + (p - solv->installed->start);
+	  /* check if identical to feature rule, we don't like that (except for orphans) */
+	  r = solv->rules + solv->featurerules + (v - solv->updaterules);
 	  if (!r->p)
 	    {
 	      /* update rule == feature rule */
 	      if (v > lastfeature)
 		lastfeature = v;
+	      /* prefer orphaned packages in dup mode */
+	      if (solv->keep_orphans)
+		{
+		  r = solv->rules + v;
+		  if (!r->d && !r->w2 && r->p == (solv->installed->start + (v - solv->updaterules)))
+		    {
+		      lastfeature = v;
+		      lastupdate = 0;
+		      break;
+		    }
+		}
 	      continue;
 	    }
 	  if (v > lastupdate)
@@ -308,6 +341,7 @@ makeruledecisions(Solver *solv)
   assert(solv->decisionq.count == 0);
   queue_push(&solv->decisionq, SYSTEMSOLVABLE);
   queue_push(&solv->decisionq_why, 0);
+  queue_push2(&solv->decisionq_reason, 0, 0);
   solv->decisionmap[SYSTEMSOLVABLE] = 1;	/* installed at level '1' */
 
   decisionstart = solv->decisionq.count;
@@ -340,7 +374,7 @@ makeruledecisions(Solver *solv)
 	    continue;
 
 	  /* do weak rules in phase 2 */
-	  if (ri < solv->learntrules && MAPTST(&solv->weakrulemap, ri))
+	  if (ri < solv->learntrules && solv->weakrulemap.size && MAPTST(&solv->weakrulemap, ri))
 	    continue;
 
 	  v = r->p;
@@ -415,8 +449,16 @@ makeruledecisions(Solver *solv)
 		v = ri;
 	      queue_push(&solv->problems, v);
 	      queue_push(&solv->problems, 0);
-	      if (solv->allowuninstall && v >= solv->featurerules && v < solv->updaterules_end)
-		solv->problems.count = oldproblemcount;
+	      if (v >= solv->featurerules && v < solv->updaterules_end)
+		{
+		  if (solv->allowuninstall || solv->allowuninstall_all || solv->allowuninstallmap.size)
+		    if (autouninstall(solv, solv->problems.elements + oldproblemcount + 1) != 0)
+		      {
+		        solv->problems.count = oldproblemcount;
+		        havedisabled = 1;
+		        break;	/* start over */
+		      }
+		}
 	      solver_disableproblem(solv, v);
 	      havedisabled = 1;
 	      break;	/* start over */
@@ -425,9 +467,9 @@ makeruledecisions(Solver *solv)
 	  assert(solv->decisionq_why.elements[i] > 0);
 
 	  /*
-	   * conflict with an rpm rule ?
+	   * conflict with a pkg rule ?
 	   */
-	  if (solv->decisionq_why.elements[i] < solv->rpmrules_end)
+	  if (solv->decisionq_why.elements[i] < solv->pkgrules_end)
 	    {
 	      if (record_proof)
 		{
@@ -439,15 +481,23 @@ makeruledecisions(Solver *solv)
 	      else
 		queue_push(&solv->problems, 0);
 	      assert(v > 0 || v == -SYSTEMSOLVABLE);
-	      POOL_DEBUG(SOLV_DEBUG_UNSOLVABLE, "conflict with rpm rule, disabling rule #%d\n", ri);
+	      POOL_DEBUG(SOLV_DEBUG_UNSOLVABLE, "conflict with pkg rule, disabling rule #%d\n", ri);
 	      if (ri >= solv->jobrules && ri < solv->jobrules_end)
 		v = -(solv->ruletojob.elements[ri - solv->jobrules] + 1);
 	      else
 		v = ri;
 	      queue_push(&solv->problems, v);
 	      queue_push(&solv->problems, 0);
-	      if (solv->allowuninstall && v >= solv->featurerules && v < solv->updaterules_end)
-		solv->problems.count = oldproblemcount;
+	      if (v >= solv->featurerules && v < solv->updaterules_end)
+		{
+		  if (solv->allowuninstall || solv->allowuninstall_all || solv->allowuninstallmap.size)
+		    if (autouninstall(solv, solv->problems.elements + oldproblemcount + 1) != 0)
+		      {
+		        solv->problems.count = oldproblemcount;
+		        havedisabled = 1;
+		        break;	/* start over */
+		      }
+		}
 	      solver_disableproblem(solv, v);
 	      havedisabled = 1;
 	      break;	/* start over */
@@ -482,7 +532,7 @@ makeruledecisions(Solver *solv)
 	      if (rr->p != vv                        /* not affecting the literal */
 		  && rr->p != -vv)
 		continue;
-	      if (MAPTST(&solv->weakrulemap, i))     /* weak: silently ignore */
+	      if (solv->weakrulemap.size && MAPTST(&solv->weakrulemap, i))     /* weak: silently ignore */
 		continue;
 		
 	      POOL_DEBUG(SOLV_DEBUG_UNSOLVABLE, " - disabling rule #%d\n", i);
@@ -495,8 +545,13 @@ makeruledecisions(Solver *solv)
 	    }
 	  queue_push(&solv->problems, 0);
 
-	  if (solv->allowuninstall && (v = autouninstall(solv, solv->problems.elements + oldproblemcount + 1)) != 0)
-	    solv->problems.count = oldproblemcount;
+	  if (solv->allowuninstall || solv->allowuninstall_all || solv->allowuninstallmap.size)
+	    if (autouninstall(solv, solv->problems.elements + oldproblemcount + 1) != 0)
+	      {
+	        solv->problems.count = oldproblemcount;
+	        havedisabled = 1;
+	        break;	/* start over */
+	      }
 
 	  for (i = oldproblemcount + 1; i < solv->problems.count - 1; i++)
 	    solver_disableproblem(solv, solv->problems.elements[i]);
@@ -509,6 +564,8 @@ makeruledecisions(Solver *solv)
       /*
        * phase 2: now do the weak assertions
        */
+      if (!solv->weakrulemap.size)
+	break;				/* no weak rules, no phase 2 */
       for (ii = 0; ii < solv->ruleassertions.count; ii++)
 	{
 	  ri = solv->ruleassertions.elements[ii];
@@ -578,14 +635,9 @@ makewatches(Solver *solv)
   int nsolvables = solv->pool->nsolvables;
 
   solv_free(solv->watches);
-				       /* lower half for removals, upper half for installs */
+  /* lower half for removals, upper half for installs */
   solv->watches = solv_calloc(2 * nsolvables, sizeof(Id));
-#if 1
-  /* do it reverse so rpm rules get triggered first (XXX: obsolete?) */
   for (i = 1, r = solv->rules + solv->nrules - 1; i < solv->nrules; i++, r--)
-#else
-  for (i = 1, r = solv->rules + 1; i < solv->nrules; i++, r++)
-#endif
     {
       if (!r->w2)		/* assertions do not need watches */
 	continue;
@@ -656,7 +708,6 @@ propagate(Solver *solv, int level)
   Id p, pkg, other_watch;
   Id *dp;
   Id *decisionmap = solv->decisionmap;
-
   Id *watches = solv->watches + pool->nsolvables;   /* place ptr in middle */
 
   POOL_DEBUG(SOLV_DEBUG_PROPAGATE, "----- propagate -----\n");
@@ -664,10 +715,10 @@ propagate(Solver *solv, int level)
   /* foreach non-propagated decision */
   while (solv->propagate_index < solv->decisionq.count)
     {
-	/*
-	 * 'pkg' was just decided
-	 * negate because our watches trigger if literal goes FALSE
-	 */
+      /*
+       * 'pkg' was just decided
+       * negate because our watches trigger if literal goes FALSE
+       */
       pkg = -solv->decisionq.elements[solv->propagate_index++];
 	
       IF_POOLDEBUG (SOLV_DEBUG_PROPAGATE)
@@ -696,11 +747,11 @@ propagate(Solver *solv, int level)
 	      solver_printrule(solv, SOLV_DEBUG_PROPAGATE, r);
 	    }
 
-	    /* 'pkg' was just decided (was set to FALSE)
-	     *
-	     *  now find other literal watch, check clause
-	     *   and advance on linked list
-	     */
+	  /*
+           * 'pkg' was just decided (was set to FALSE), so this rule
+	   * may now be unit.
+	   */
+	  /* find the other watch */
 	  if (pkg == r->w1)
 	    {
 	      other_watch = r->w2;
@@ -712,17 +763,16 @@ propagate(Solver *solv, int level)
 	      next_rp = &r->n2;
 	    }
 
-	    /*
-	     * This term is already true (through the other literal)
-	     * so we have nothing to do
-	     */
+	  /*
+	   * if the other watch is true we have nothing to do
+	   */
 	  if (DECISIONMAP_TRUE(other_watch))
 	    continue;
 
-	    /*
-	     * The other literal is FALSE or UNDEF
-	     *
-	     */
+	  /*
+	   * The other literal is FALSE or UNDEF
+	   *
+	   */
 
           if (r->d)
 	    {
@@ -733,6 +783,8 @@ propagate(Solver *solv, int level)
 	       *   and not FALSE
 	       *
 	       * (TRUE is also ok, in that case the rule is fulfilled)
+	       * As speed matters here we do not use the FOR_RULELITERALS
+	       * macro.
 	       */
 	      if (r->p                                /* we have a 'p' */
 		  && r->p != other_watch              /* which is not watched */
@@ -764,7 +816,7 @@ propagate(Solver *solv, int level)
 		      if (p > 0)
 			POOL_DEBUG(SOLV_DEBUG_PROPAGATE, "    -> move w%d to %s\n", (pkg == r->w1 ? 1 : 2), pool_solvid2str(pool, p));
 		      else
-			POOL_DEBUG(SOLV_DEBUG_PROPAGATE,"    -> move w%d to !%s\n", (pkg == r->w1 ? 1 : 2), pool_solvid2str(pool, -p));
+			POOL_DEBUG(SOLV_DEBUG_PROPAGATE, "    -> move w%d to !%s\n", (pkg == r->w1 ? 1 : 2), pool_solvid2str(pool, -p));
 		    }
 
 		  *rp = *next_rp;
@@ -831,25 +883,85 @@ propagate(Solver *solv, int level)
 
 /*-------------------------------------------------------------------
  *
+ * revert
+ * revert decisionq to a level
+ */
+
+static void
+revert(Solver *solv, int level)
+{
+  Pool *pool = solv->pool;
+  Id v, vv;
+  while (solv->decisionq.count)
+    {
+      v = solv->decisionq.elements[solv->decisionq.count - 1];
+      vv = v > 0 ? v : -v;
+      if (solv->decisionmap[vv] <= level && solv->decisionmap[vv] >= -level)
+        break;
+      POOL_DEBUG(SOLV_DEBUG_PROPAGATE, "reverting decision %d at %d\n", v, solv->decisionmap[vv]);
+      solv->decisionmap[vv] = 0;
+      solv->decisionq.count--;
+      solv->decisionq_why.count--;
+      solv->propagate_index = solv->decisionq.count;
+    }
+  while (solv->branches.count && solv->branches.elements[solv->branches.count - 1] >= level)
+    solv->branches.count -= solv->branches.elements[solv->branches.count - 2];
+  if (solv->recommends_index > solv->decisionq.count)
+    solv->recommends_index = -1;	/* rebuild recommends/suggests maps */
+  solv->decisionq_reason.count = level + 1;
+}
+
+/*-------------------------------------------------------------------
+ *
+ * watch2onhighest - put watch2 on literal with highest level
+ */
+
+static inline void
+watch2onhighest(Solver *solv, Rule *r)
+{
+  int l, wl = 0;
+  Id d, v, *dp;
+
+  d = r->d < 0 ? -r->d - 1 : r->d;
+  if (!d)
+    return;	/* binary rule, both watches are set */
+  dp = solv->pool->whatprovidesdata + d;
+  while ((v = *dp++) != 0)
+    {
+      l = solv->decisionmap[v < 0 ? -v : v];
+      if (l < 0)
+	l = -l;
+      if (l > wl)
+	{
+	  r->w2 = dp[-1];
+	  wl = l;
+	}
+    }
+}
+
+
+/*-------------------------------------------------------------------
+ *
  * analyze
  *   and learn
  */
 
 static int
-analyze(Solver *solv, int level, Rule *c, int *pr, int *dr, int *whyp)
+analyze(Solver *solv, int level, Rule *c, Rule **lrp)
 {
   Pool *pool = solv->pool;
-  Queue r;
-  Id r_buf[4];
+  Queue q;
+  Rule *r;
+  Id q_buf[8];
   int rlevel = 1;
   Map seen;		/* global? */
-  Id d, v, vv, *dp, why;
+  Id p = 0, pp, v, vv, why;
   int l, i, idx;
   int num = 0, l1num = 0;
   int learnt_why = solv->learnt_pool.count;
   Id *decisionmap = solv->decisionmap;
 
-  queue_init_buffer(&r, r_buf, sizeof(r_buf)/sizeof(*r_buf));
+  queue_init_buffer(&q, q_buf, sizeof(q_buf)/sizeof(*q_buf));
 
   POOL_DEBUG(SOLV_DEBUG_ANALYZE, "ANALYZE at %d ----------------------\n", level);
   map_init(&seen, pool->nsolvables);
@@ -859,43 +971,31 @@ analyze(Solver *solv, int level, Rule *c, int *pr, int *dr, int *whyp)
       IF_POOLDEBUG (SOLV_DEBUG_ANALYZE)
 	solver_printruleclass(solv, SOLV_DEBUG_ANALYZE, c);
       queue_push(&solv->learnt_pool, c - solv->rules);
-      d = c->d < 0 ? -c->d - 1 : c->d;
-      dp = d ? pool->whatprovidesdata + d : 0;
-      /* go through all literals of the rule */
-      for (i = -1; ; i++)
+      FOR_RULELITERALS(v, pp, c)
 	{
-	  if (i == -1)
-	    v = c->p;
-	  else if (d == 0)
-	    v = i ? 0 : c->w2;
-	  else
-	    v = *dp++;
-	  if (v == 0)
-	    break;
-
 	  if (DECISIONMAP_TRUE(v))	/* the one true literal */
 	    continue;
 	  vv = v > 0 ? v : -v;
 	  if (MAPTST(&seen, vv))
 	    continue;
+	  MAPSET(&seen, vv);		/* mark that we also need to look at this literal */
 	  l = solv->decisionmap[vv];
 	  if (l < 0)
 	    l = -l;
-	  MAPSET(&seen, vv);		/* mark that we also need to look at this literal */
 	  if (l == 1)
 	    l1num++;			/* need to do this one in level1 pass */
 	  else if (l == level)
 	    num++;			/* need to do this one as well */
 	  else
 	    {
-	      queue_push(&r, v);	/* not level1 or conflict level, add to new rule */
+	      queue_push(&q, v);	/* not level1 or conflict level, add to new rule */
 	      if (l > rlevel)
 		rlevel = l;
 	    }
 	}
 l1retry:
       if (!num && !--l1num)
-	break;	/* all level 1 literals done */
+	break;	/* all literals done */
 
       /* find the next literal to investigate */
       /* (as num + l1num > 0, we know that we'll always find one) */
@@ -911,14 +1011,15 @@ l1retry:
 
       if (num && --num == 0)
 	{
-	  *pr = -v;	/* so that v doesn't get lost */
+	  /* done with normal literals, now start level 1 literal processing */
+	  p = -v;	/* so that v doesn't get lost */
 	  if (!l1num)
 	    break;
 	  POOL_DEBUG(SOLV_DEBUG_ANALYZE, "got %d involved level 1 decisions\n", l1num);
 	  /* clear non-l1 bits from seen map */
-	  for (i = 0; i < r.count; i++)
+	  for (i = 0; i < q.count; i++)
 	    {
-	      v = r.elements[i];
+	      v = q.elements[i];
 	      MAPCLR(&seen, v > 0 ? v : -v);
 	    }
 	  /* only level 1 marks left in seen map */
@@ -932,27 +1033,49 @@ l1retry:
       c = solv->rules + why;
     }
   map_free(&seen);
-
-  if (r.count == 0)
-    *dr = 0;
-  else if (r.count == 1 && r.elements[0] < 0)
-    *dr = r.elements[0];
-  else
-    *dr = pool_queuetowhatprovides(pool, &r);
+  assert(p != 0);
+  assert(rlevel > 0 && rlevel < level);
   IF_POOLDEBUG (SOLV_DEBUG_ANALYZE)
     {
       POOL_DEBUG(SOLV_DEBUG_ANALYZE, "learned rule for level %d (am %d)\n", rlevel, level);
-      solver_printruleelement(solv, SOLV_DEBUG_ANALYZE, 0, *pr);
-      for (i = 0; i < r.count; i++)
-        solver_printruleelement(solv, SOLV_DEBUG_ANALYZE, 0, r.elements[i]);
+      solver_printruleelement(solv, SOLV_DEBUG_ANALYZE, 0, p);
+      for (i = 0; i < q.count; i++)
+        solver_printruleelement(solv, SOLV_DEBUG_ANALYZE, 0, q.elements[i]);
     }
   /* push end marker on learnt reasons stack */
   queue_push(&solv->learnt_pool, 0);
-  if (whyp)
-    *whyp = learnt_why;
-  queue_free(&r);
   solv->stats_learned++;
-  return rlevel;
+
+  POOL_DEBUG(SOLV_DEBUG_ANALYZE, "reverting decisions (level %d -> %d)\n", level, rlevel);
+  level = rlevel;
+  revert(solv, level);
+  if (q.count < 2)
+    {
+      Id d = q.count ? q.elements[0] : 0;
+      queue_free(&q);
+      r = solver_addrule(solv, p, d, 0);
+    }
+  else
+    {
+      Id d = pool_queuetowhatprovides(pool, &q);
+      queue_free(&q);
+      r = solver_addrule(solv, p, 0, d);
+    }
+  assert(solv->learnt_why.count == (r - solv->rules) - solv->learntrules);
+  queue_push(&solv->learnt_why, learnt_why);
+  if (r->w2)
+    {
+      /* needs watches */
+      watch2onhighest(solv, r);
+      addwatches_rule(solv, r);
+    }
+  else
+    {
+      /* rule is an assertion */
+      queue_push(&solv->ruleassertions, r - solv->rules);
+    }
+  *lrp = r;
+  return level;
 }
 
 
@@ -967,7 +1090,6 @@ l1retry:
 void
 solver_reset(Solver *solv)
 {
-  Pool *pool = solv->pool;
   int i;
   Id v;
 
@@ -979,17 +1101,13 @@ solver_reset(Solver *solv)
     }
   queue_empty(&solv->decisionq_why);
   queue_empty(&solv->decisionq);
+  queue_empty(&solv->decisionq_reason);
   solv->recommends_index = -1;
   solv->propagate_index = 0;
-  solv->decisioncnt_update = solv->decisioncnt_keep = solv->decisioncnt_resolve = solv->decisioncnt_weak = solv->decisioncnt_orphan = 0;
   queue_empty(&solv->branches);
 
   /* adapt learnt rule status to new set of enabled/disabled rules */
   enabledisablelearntrules(solv);
-
-  /* redo all assertion rule decisions */
-  makeruledecisions(solv);
-  POOL_DEBUG(SOLV_DEBUG_UNSOLVABLE, "decisions so far: %d\n", solv->decisionq.count);
 }
 
 
@@ -1019,11 +1137,11 @@ analyze_unsolvable_rule(Solver *solv, Rule *r, Id *lastweakp, Map *rseen)
 	  analyze_unsolvable_rule(solv, solv->rules + solv->learnt_pool.elements[i], lastweakp, rseen);
       return;
     }
-  if (MAPTST(&solv->weakrulemap, why))
+  if (solv->weakrulemap.size && MAPTST(&solv->weakrulemap, why))
     if (!*lastweakp || why > *lastweakp)
       *lastweakp = why;
-  /* do not add rpm rules to problem */
-  if (why < solv->rpmrules_end)
+  /* do not add pkg rules to problem */
+  if (why < solv->pkgrules_end)
     return;
   /* turn rule into problem */
   if (why >= solv->jobrules && why < solv->jobrules_end)
@@ -1057,22 +1175,22 @@ analyze_unsolvable_rule(Solver *solv, Rule *r, Id *lastweakp, Map *rseen)
 
 /*-------------------------------------------------------------------
  *
- * analyze_unsolvable
+ * analyze_unsolvable (called from setpropagatelearn)
  *
  * We know that the problem is not solvable. Record all involved
  * rules (i.e. the "proof") into solv->learnt_pool.
- * Record the learnt pool index and all non-rpm rules into
+ * Record the learnt pool index and all non-pkg rules into
  * solv->problems. (Our solutions to fix the problems are to
  * disable those rules.)
  *
  * If the proof contains at least one weak rule, we disable the
  * last of them.
  *
- * Otherwise we return 0 if disablerules is not set or disable
- * _all_ of the problem rules and return 1.
+ * Otherwise we return -1 if disablerules is not set or disable
+ * _all_ of the problem rules and return 0.
  *
- * return: 1 - disabled some rules, try again
- *         0 - hopeless
+ * return:  0 - disabled some rules, try again
+ *         -1 - hopeless
  */
 
 static int
@@ -1080,10 +1198,10 @@ analyze_unsolvable(Solver *solv, Rule *cr, int disablerules)
 {
   Pool *pool = solv->pool;
   Rule *r;
-  Map seen;		/* global to speed things up? */
+  Map involved;		/* global to speed things up? */
   Map rseen;
-  Id d, v, vv, *dp, why;
-  int l, i, idx;
+  Id pp, v, vv, why;
+  int i, idx;
   Id *decisionmap = solv->decisionmap;
   int oldproblemcount;
   int oldlearntpoolcount;
@@ -1101,38 +1219,25 @@ analyze_unsolvable(Solver *solv, Rule *cr, int disablerules)
   queue_push(&solv->problems, 0);
 
   r = cr;
-  map_init(&seen, pool->nsolvables);
+  map_init(&involved, pool->nsolvables);
   map_init(&rseen, solv->learntrules ? solv->nrules - solv->learntrules : 0);
   if (record_proof)
     queue_push(&solv->learnt_pool, r - solv->rules);
   lastweak = 0;
   analyze_unsolvable_rule(solv, r, &lastweak, &rseen);
-  d = r->d < 0 ? -r->d - 1 : r->d;
-  dp = d ? pool->whatprovidesdata + d : 0;
-  for (i = -1; ; i++)
+  FOR_RULELITERALS(v, pp, r)
     {
-      if (i == -1)
-	v = r->p;
-      else if (d == 0)
-	v = i ? 0 : r->w2;
-      else
-	v = *dp++;
-      if (v == 0)
-	break;
       if (DECISIONMAP_TRUE(v))	/* the one true literal */
 	  continue;
       vv = v > 0 ? v : -v;
-      l = solv->decisionmap[vv];
-      if (l < 0)
-	l = -l;
-      MAPSET(&seen, vv);
+      MAPSET(&involved, vv);
     }
   idx = solv->decisionq.count;
   while (idx > 0)
     {
       v = solv->decisionq.elements[--idx];
       vv = v > 0 ? v : -v;
-      if (!MAPTST(&seen, vv))
+      if (!MAPTST(&involved, vv) || vv == SYSTEMSOLVABLE)
 	continue;
       why = solv->decisionq_why.elements[idx];
       assert(why > 0);
@@ -1140,28 +1245,15 @@ analyze_unsolvable(Solver *solv, Rule *cr, int disablerules)
         queue_push(&solv->learnt_pool, why);
       r = solv->rules + why;
       analyze_unsolvable_rule(solv, r, &lastweak, &rseen);
-      d = r->d < 0 ? -r->d - 1 : r->d;
-      dp = d ? pool->whatprovidesdata + d : 0;
-      for (i = -1; ; i++)
+      FOR_RULELITERALS(v, pp, r)
 	{
-	  if (i == -1)
-	    v = r->p;
-	  else if (d == 0)
-	    v = i ? 0 : r->w2;
-	  else
-	    v = *dp++;
-	  if (v == 0)
-	    break;
 	  if (DECISIONMAP_TRUE(v))	/* the one true literal */
 	      continue;
 	  vv = v > 0 ? v : -v;
-	  l = solv->decisionmap[vv];
-	  if (l < 0)
-	    l = -l;
-	  MAPSET(&seen, vv);
+	  MAPSET(&involved, vv);
 	}
     }
-  map_free(&seen);
+  map_free(&involved);
   map_free(&rseen);
   queue_push(&solv->problems, 0);	/* mark end of this problem */
 
@@ -1182,16 +1274,17 @@ analyze_unsolvable(Solver *solv, Rule *cr, int disablerules)
       if (v < 0)
 	solver_reenablepolicyrules(solv, -v);
       solver_reset(solv);
-      return 1;
+      return 0;
     }
 
-  if (solv->allowuninstall && (v = autouninstall(solv, solv->problems.elements + oldproblemcount + 1)) != 0)
-    {
-      solv->problems.count = oldproblemcount;
-      solv->learnt_pool.count = oldlearntpoolcount;
-      solver_reset(solv);
-      return 1;
-    }
+  if (solv->allowuninstall || solv->allowuninstall_all || solv->allowuninstallmap.size)
+    if (autouninstall(solv, solv->problems.elements + oldproblemcount + 1) != 0)
+      {
+	solv->problems.count = oldproblemcount;
+	solv->learnt_pool.count = oldlearntpoolcount;
+	solver_reset(solv);
+	return 0;
+      }
 
   /* finish proof */
   if (record_proof)
@@ -1207,85 +1300,10 @@ analyze_unsolvable(Solver *solv, Rule *cr, int disablerules)
         solver_disableproblem(solv, solv->problems.elements[i]);
       /* XXX: might want to enable all weak rules again */
       solver_reset(solv);
-      return 1;
+      return 0;
     }
   POOL_DEBUG(SOLV_DEBUG_UNSOLVABLE, "UNSOLVABLE\n");
-  return 0;
-}
-
-
-/********************************************************************/
-/* Decision revert */
-
-/*-------------------------------------------------------------------
- *
- * revert
- * revert decisionq to a level
- */
-
-static void
-revert(Solver *solv, int level)
-{
-  Pool *pool = solv->pool;
-  Id v, vv;
-  while (solv->decisionq.count)
-    {
-      v = solv->decisionq.elements[solv->decisionq.count - 1];
-      vv = v > 0 ? v : -v;
-      if (solv->decisionmap[vv] <= level && solv->decisionmap[vv] >= -level)
-        break;
-      POOL_DEBUG(SOLV_DEBUG_PROPAGATE, "reverting decision %d at %d\n", v, solv->decisionmap[vv]);
-      solv->decisionmap[vv] = 0;
-      solv->decisionq.count--;
-      solv->decisionq_why.count--;
-      solv->propagate_index = solv->decisionq.count;
-    }
-  while (solv->branches.count && solv->branches.elements[solv->branches.count - 1] <= -level)
-    {
-      solv->branches.count--;
-      while (solv->branches.count && solv->branches.elements[solv->branches.count - 1] >= 0)
-	solv->branches.count--;
-    }
-  solv->recommends_index = -1;
-  if (solv->decisionq.count < solv->decisioncnt_update)
-    solv->decisioncnt_update = 0;
-  if (solv->decisionq.count < solv->decisioncnt_keep)
-    solv->decisioncnt_keep = 0;
-  if (solv->decisionq.count < solv->decisioncnt_resolve)
-    solv->decisioncnt_resolve = 0;
-  if (solv->decisionq.count < solv->decisioncnt_weak)
-    solv->decisioncnt_weak= 0;
-  if (solv->decisionq.count < solv->decisioncnt_orphan)
-    solv->decisioncnt_orphan = 0;
-}
-
-
-/*-------------------------------------------------------------------
- *
- * watch2onhighest - put watch2 on literal with highest level
- */
-
-static inline void
-watch2onhighest(Solver *solv, Rule *r)
-{
-  int l, wl = 0;
-  Id d, v, *dp;
-
-  d = r->d < 0 ? -r->d - 1 : r->d;
-  if (!d)
-    return;	/* binary rule, both watches are set */
-  dp = solv->pool->whatprovidesdata + d;
-  while ((v = *dp++) != 0)
-    {
-      l = solv->decisionmap[v < 0 ? -v : v];
-      if (l < 0)
-	l = -l;
-      if (l > wl)
-	{
-	  r->w2 = dp[-1];
-	  wl = l;
-	}
-    }
+  return -1;
 }
 
 
@@ -1301,19 +1319,16 @@ watch2onhighest(Solver *solv, Rule *r)
  * rule to learnt rule set, make decision from learnt
  * rule (always unit) and re-propagate.
  *
- * returns the new solver level or 0 if unsolvable
+ * returns the new solver level or -1 if unsolvable
  *
  */
 
 static int
-setpropagatelearn(Solver *solv, int level, Id decision, int disablerules, Id ruleid)
+setpropagatelearn(Solver *solv, int level, Id decision, int disablerules, Id ruleid, Id reason)
 {
   Pool *pool = solv->pool;
-  Rule *r;
-  Id p = 0, d = 0;
-  int l, why;
+  Rule *r, *lr;
 
-  assert(ruleid >= 0);
   if (decision)
     {
       level++;
@@ -1323,7 +1338,9 @@ setpropagatelearn(Solver *solv, int level, Id decision, int disablerules, Id rul
         solv->decisionmap[-decision] = -level;
       queue_push(&solv->decisionq, decision);
       queue_push(&solv->decisionq_why, -ruleid);	/* <= 0 -> free decision */
+      queue_push(&solv->decisionq_reason, reason);
     }
+  assert(ruleid >= 0 && level > 0);
   for (;;)
     {
       r = propagate(solv, level);
@@ -1332,46 +1349,29 @@ setpropagatelearn(Solver *solv, int level, Id decision, int disablerules, Id rul
       if (level == 1)
 	return analyze_unsolvable(solv, r, disablerules);
       POOL_DEBUG(SOLV_DEBUG_ANALYZE, "conflict with rule #%d\n", (int)(r - solv->rules));
-      l = analyze(solv, level, r, &p, &d, &why);	/* learnt rule in p and d */
-      assert(l > 0 && l < level);
-      POOL_DEBUG(SOLV_DEBUG_ANALYZE, "reverting decisions (level %d -> %d)\n", level, l);
-      level = l;
-      revert(solv, level);
-      r = solver_addrule(solv, p, d);
-      assert(r);
-      assert(solv->learnt_why.count == (r - solv->rules) - solv->learntrules);
-      queue_push(&solv->learnt_why, why);
-      if (d)
-	{
-	  /* at least 2 literals, needs watches */
-	  watch2onhighest(solv, r);
-	  addwatches_rule(solv, r);
-	}
-      else
-	{
-	  /* learnt rule is an assertion */
-          queue_push(&solv->ruleassertions, r - solv->rules);
-	}
+      level = analyze(solv, level, r, &lr);
       /* the new rule is unit by design */
-      solv->decisionmap[p > 0 ? p : -p] = p > 0 ? level : -level;
-      queue_push(&solv->decisionq, p);
-      queue_push(&solv->decisionq_why, r - solv->rules);
+      decision = lr->p;
+      solv->decisionmap[decision > 0 ? decision : -decision] = decision > 0 ? level : -level;
+      queue_push(&solv->decisionq, decision);
+      queue_push(&solv->decisionq_why, lr - solv->rules);
       IF_POOLDEBUG (SOLV_DEBUG_ANALYZE)
 	{
 	  POOL_DEBUG(SOLV_DEBUG_ANALYZE, "decision: ");
-	  solver_printruleelement(solv, SOLV_DEBUG_ANALYZE, 0, p);
+	  solver_printruleelement(solv, SOLV_DEBUG_ANALYZE, 0, decision);
 	  POOL_DEBUG(SOLV_DEBUG_ANALYZE, "new rule: ");
-	  solver_printrule(solv, SOLV_DEBUG_ANALYZE, r);
+	  solver_printrule(solv, SOLV_DEBUG_ANALYZE, lr);
 	}
     }
   return level;
 }
 
 static void
-reorder_dq_for_jobrules(Solver *solv, int level, Queue *dq)
+reorder_dq_for_future_installed(Solver *solv, int level, Queue *dq)
 {
   Pool *pool = solv->pool;
   int i, j, haveone = 0, dqcount = dq->count;
+  int decisionqcount = solv->decisionq.count;
   Id p;
   Solvable *s;
 
@@ -1383,33 +1383,101 @@ reorder_dq_for_jobrules(Solver *solv, int level, Queue *dq)
 	continue;
       if (solv->decisionmap[p] == 0)
 	{
-	  solv->decisionmap[p] = level;
+	  if (s->recommends || s->suggests)
+	    queue_push(&solv->decisionq, p);
+	  solv->decisionmap[p] = level + 1;
 	  haveone = 1;
 	}
     }
   if (!haveone)
     return;
+  policy_update_recommendsmap(solv);
   for (i = 0; i < dqcount; i++)
-    if (!solver_is_enhancing(solv, pool->solvables + dq->elements[i]))
-      {
-	queue_push(dq, dq->elements[i]);
-	dq->elements[i] = 0;
-      }
+    {
+      p = dq->elements[i];
+      if (!(pool->solvables[p].repo == solv->installed || MAPTST(&solv->suggestsmap, p) || solver_is_enhancing(solv, pool->solvables + p)))
+        {
+	  queue_push(dq, p);
+	  dq->elements[i] = 0;
+        }
+    }
   dqcount = dq->count;
   for (i = 0; i < dqcount; i++)
-    if (dq->elements[i] && !solver_is_supplementing(solv, pool->solvables + dq->elements[i]))
-      {
-	queue_push(dq, dq->elements[i]);
-	dq->elements[i] = 0;
-      }
+    {
+      p = dq->elements[i];
+      if (p && !(pool->solvables[p].repo == solv->installed || MAPTST(&solv->recommendsmap, p) || solver_is_supplementing(solv, pool->solvables + p)))
+        {
+	  queue_push(dq, p);
+	  dq->elements[i] = 0;
+        }
+    }
   for (i = j = 0; i < dq->count; i++)
     if (dq->elements[i])
       dq->elements[j++] = dq->elements[i];
   queue_truncate(dq, j);
   FOR_REPO_SOLVABLES(solv->installed, p, s)
-    if (solv->decisionmap[p] == level)
+    if (solv->decisionmap[p] == level + 1)
       solv->decisionmap[p] = 0;
-}
+  if (solv->decisionq.count != decisionqcount)
+    {
+      solv->recommends_index = -1;
+      queue_truncate(&solv->decisionq, decisionqcount);
+    }
+  /* but obey favored maps */
+  policy_prefer_favored(solv, dq);
+}
+
+/*-------------------------------------------------------------------
+ *
+ * branch handling
+ */
+
+static void
+createbranch(Solver *solv, int level, Queue *dq, Id p, Id data)
+{
+  Pool *pool = solv->pool;
+  int i;
+  IF_POOLDEBUG (SOLV_DEBUG_POLICY)
+    {
+      POOL_DEBUG (SOLV_DEBUG_POLICY, "creating a branch:\n");
+      for (i = 0; i < dq->count; i++)
+	POOL_DEBUG (SOLV_DEBUG_POLICY, "  - %s\n", pool_solvid2str(pool, dq->elements[i]));
+    }
+  queue_push(&solv->branches, -dq->elements[0]);
+  for (i = 1; i < dq->count; i++)
+    queue_push(&solv->branches, dq->elements[i]);
+  queue_push2(&solv->branches, p, data);
+  queue_push2(&solv->branches, dq->count + 4, level);
+}
+
+static int
+takebranch(Solver *solv, int pos, int end, const char *msg, int disablerules)
+{
+  Pool *pool = solv->pool;
+  int level;
+  Id p, why, reason;
+#if 0
+  {
+    int i;
+    printf("branch group level %d [%d-%d] %d %d:\n", solv->branches.elements[end - 1], start, end, solv->branches.elements[end - 4], solv->branches.elements[end - 3]);
+    for (i = end - solv->branches.elements[end - 2]; i < end - 4; i++)
+      printf("%c %c%s\n", i == pos ? 'x' : ' ', solv->branches.elements[i] >= 0 ? ' ' : '-', pool_solvid2str(pool, solv->branches.elements[i] >= 0 ? solv->branches.elements[i] : -solv->branches.elements[i]));
+  }
+#endif
+  level = solv->branches.elements[end - 1];
+  p = solv->branches.elements[pos];
+  solv->branches.elements[pos] = -p;
+  POOL_DEBUG(SOLV_DEBUG_SOLVER, "%s %d -> %d with %s\n", msg, solv->decisionmap[p], level, pool_solvid2str(pool, p));
+  /* hack: set level to zero so that revert does not remove the branch */
+  solv->branches.elements[end - 1] = 0;
+  revert(solv, level);
+  solv->branches.elements[end - 1] = level;
+  /* hack: revert simply sets the count, so we can still access the reverted elements */
+  why = -solv->decisionq_why.elements[solv->decisionq_why.count];
+  assert(why >= 0);
+  reason = solv->decisionq_reason.elements[level + 1];
+  return setpropagatelearn(solv, level, p, disablerules, why, reason);
+}
 
 /*-------------------------------------------------------------------
  *
@@ -1418,47 +1486,28 @@ reorder_dq_for_jobrules(Solver *solv, int level, Queue *dq)
  * install best package from the queue. We add an extra package, inst, if
  * provided. See comment in weak install section.
  *
- * returns the new solver level or 0 if unsolvable
+ * returns the new solver level or -1 if unsolvable
  *
  */
 
 static int
-selectandinstall(Solver *solv, int level, Queue *dq, int disablerules, Id ruleid)
+selectandinstall(Solver *solv, int level, Queue *dq, int disablerules, Id ruleid, Id reason)
 {
   Pool *pool = solv->pool;
   Id p;
-  int i;
 
   if (dq->count > 1)
     policy_filter_unwanted(solv, dq, POLICY_MODE_CHOOSE);
+  /* if we're resolving rules and didn't resolve the installed packages yet,
+   * do some special supplements ordering */
+  if (dq->count > 1 && solv->do_extra_reordering)
+    reorder_dq_for_future_installed(solv, level, dq);
+  /* if we have multiple candidates we open a branch */
   if (dq->count > 1)
-    {
-      /* XXX: didn't we already do that? */
-      /* XXX: shouldn't we prefer installed packages? */
-      /* XXX: move to policy.c? */
-      /* choose the supplemented one */
-      for (i = 0; i < dq->count; i++)
-	if (solver_is_supplementing(solv, pool->solvables + dq->elements[i]))
-	  {
-	    dq->elements[0] = dq->elements[i];
-	    dq->count = 1;
-	    break;
-	  }
-    }
-  if (dq->count > 1 && ruleid >= solv->jobrules && ruleid < solv->jobrules_end && solv->installed)
-    reorder_dq_for_jobrules(solv, level, dq);
-  if (dq->count > 1)
-    {
-      /* multiple candidates, open a branch */
-      for (i = 1; i < dq->count; i++)
-	queue_push(&solv->branches, dq->elements[i]);
-      queue_push(&solv->branches, -level);
-    }
+    createbranch(solv, level, dq, 0, ruleid);
   p = dq->elements[0];
-
   POOL_DEBUG(SOLV_DEBUG_POLICY, "installing %s\n", pool_solvid2str(pool, p));
-
-  return setpropagatelearn(solv, level, p, disablerules, ruleid);
+  return setpropagatelearn(solv, level, p, disablerules, ruleid, reason);
 }
 
 
@@ -1499,6 +1548,7 @@ solver_create(Pool *pool)
   queue_init(&solv->ruletojob);
   queue_init(&solv->decisionq);
   queue_init(&solv->decisionq_why);
+  queue_init(&solv->decisionq_reason);
   queue_init(&solv->problems);
   queue_init(&solv->orphaned);
   queue_init(&solv->learnt_why);
@@ -1524,11 +1574,31 @@ solver_create(Pool *pool)
 }
 
 
+
 /*-------------------------------------------------------------------
  *
  * solver_free
  */
 
+static inline void
+queuep_free(Queue **qp)
+{
+  if (!*qp)
+    return;
+  queue_free(*qp);
+  *qp = solv_free(*qp);
+}
+
+static inline void
+map_zerosize(Map *m)
+{
+  if (m->size)
+    {
+      map_free(m);
+      map_init(m, 0);
+    }
+}
+
 void
 solver_free(Solver *solv)
 {
@@ -1536,6 +1606,7 @@ solver_free(Solver *solv)
   queue_free(&solv->ruletojob);
   queue_free(&solv->decisionq);
   queue_free(&solv->decisionq_why);
+  queue_free(&solv->decisionq_reason);
   queue_free(&solv->learnt_why);
   queue_free(&solv->learnt_pool);
   queue_free(&solv->problems);
@@ -1545,26 +1616,14 @@ solver_free(Solver *solv)
   queue_free(&solv->weakruleq);
   queue_free(&solv->ruleassertions);
   queue_free(&solv->addedmap_deduceq);
-  if (solv->cleandeps_updatepkgs)
-    {
-      queue_free(solv->cleandeps_updatepkgs);
-      solv->cleandeps_updatepkgs = solv_free(solv->cleandeps_updatepkgs);
-    }
-  if (solv->cleandeps_mistakes)
-    {
-      queue_free(solv->cleandeps_mistakes);
-      solv->cleandeps_mistakes = solv_free(solv->cleandeps_mistakes);
-    }
-  if (solv->update_targets)
-    {
-      queue_free(solv->update_targets);
-      solv->update_targets = solv_free(solv->update_targets);
-    }
-  if (solv->installsuppdepq)
-    {
-      queue_free(solv->installsuppdepq);
-      solv->installsuppdepq = solv_free(solv->installsuppdepq);
-    }
+  queuep_free(&solv->cleandeps_updatepkgs);
+  queuep_free(&solv->cleandeps_mistakes);
+  queuep_free(&solv->update_targets);
+  queuep_free(&solv->installsuppdepq);
+  queuep_free(&solv->recommendscplxq);
+  queuep_free(&solv->suggestscplxq);
+  queuep_free(&solv->brokenorphanrules);
+  queuep_free(&solv->favorq);
 
   map_free(&solv->recommendsmap);
   map_free(&solv->suggestsmap);
@@ -1579,15 +1638,19 @@ solver_free(Solver *solv)
   map_free(&solv->dupinvolvedmap);
   map_free(&solv->droporphanedmap);
   map_free(&solv->cleandepsmap);
+  map_free(&solv->allowuninstallmap);
+  map_free(&solv->favormap);
+  map_free(&solv->isdisfavormap);
 
   solv_free(solv->decisionmap);
   solv_free(solv->rules);
   solv_free(solv->watches);
   solv_free(solv->obsoletes);
   solv_free(solv->obsoletes_data);
-  solv_free(solv->multiversionupdaters);
+  solv_free(solv->specialupdaters);
   solv_free(solv->choicerules_ref);
   solv_free(solv->bestrules_pkg);
+  solv_free(solv->yumobsrules_info);
   solv_free(solv->instbuddy);
   solv_free(solv);
 }
@@ -1623,6 +1686,28 @@ solver_get_flag(Solver *solv, int flag)
     return solv->bestobeypolicy;
   case SOLVER_FLAG_NO_AUTOTARGET:
     return solv->noautotarget;
+  case SOLVER_FLAG_DUP_ALLOW_DOWNGRADE:
+    return solv->dup_allowdowngrade;
+  case SOLVER_FLAG_DUP_ALLOW_NAMECHANGE:
+    return solv->dup_allownamechange;
+  case SOLVER_FLAG_DUP_ALLOW_ARCHCHANGE:
+    return solv->dup_allowarchchange;
+  case SOLVER_FLAG_DUP_ALLOW_VENDORCHANGE:
+    return solv->dup_allowvendorchange;
+  case SOLVER_FLAG_KEEP_ORPHANS:
+    return solv->keep_orphans;
+  case SOLVER_FLAG_BREAK_ORPHANS:
+    return solv->break_orphans;
+  case SOLVER_FLAG_FOCUS_INSTALLED:
+    return solv->focus_installed;
+  case SOLVER_FLAG_FOCUS_BEST:
+    return solv->focus_best;
+  case SOLVER_FLAG_YUM_OBSOLETES:
+    return solv->do_yum_obsoletes;
+  case SOLVER_FLAG_NEED_UPDATEPROVIDE:
+    return solv->needupdateprovide;
+  case SOLVER_FLAG_URPM_REORDER:
+    return solv->urpmreorder;
   default:
     break;
   }
@@ -1674,14 +1759,120 @@ solver_set_flag(Solver *solv, int flag, int value)
   case SOLVER_FLAG_NO_AUTOTARGET:
     solv->noautotarget = value;
     break;
+  case SOLVER_FLAG_DUP_ALLOW_DOWNGRADE:
+    solv->dup_allowdowngrade = value;
+    break;
+  case SOLVER_FLAG_DUP_ALLOW_NAMECHANGE:
+    solv->dup_allownamechange = value;
+    break;
+  case SOLVER_FLAG_DUP_ALLOW_ARCHCHANGE:
+    solv->dup_allowarchchange = value;
+    break;
+  case SOLVER_FLAG_DUP_ALLOW_VENDORCHANGE:
+    solv->dup_allowvendorchange = value;
+    break;
+  case SOLVER_FLAG_KEEP_ORPHANS:
+    solv->keep_orphans = value;
+    break;
+  case SOLVER_FLAG_BREAK_ORPHANS:
+    solv->break_orphans = value;
+    break;
+  case SOLVER_FLAG_FOCUS_INSTALLED:
+    solv->focus_installed = value;
+    break;
+  case SOLVER_FLAG_FOCUS_BEST:
+    solv->focus_best = value;
+    break;
+  case SOLVER_FLAG_YUM_OBSOLETES:
+    solv->do_yum_obsoletes = value;
+    break;
+  case SOLVER_FLAG_NEED_UPDATEPROVIDE:
+    solv->needupdateprovide = value;
+    break;
+  case SOLVER_FLAG_URPM_REORDER:
+    solv->urpmreorder = value;
+    break;
   default:
     break;
   }
   return old;
 }
 
-int
-cleandeps_check_mistakes(Solver *solv, int level)
+static int
+resolve_jobrules(Solver *solv, int level, int disablerules, Queue *dq)
+{
+  Pool *pool = solv->pool;
+  int oldlevel = level;
+  int i, olevel;
+  Rule *r;
+
+  POOL_DEBUG(SOLV_DEBUG_SOLVER, "resolving job rules\n");
+  for (i = solv->jobrules, r = solv->rules + i; i < solv->jobrules_end; i++, r++)
+    {
+      Id l, pp;
+      if (r->d < 0)		/* ignore disabled rules */
+	continue;
+      queue_empty(dq);
+      FOR_RULELITERALS(l, pp, r)
+	{
+	  if (l < 0)
+	    {
+	      if (solv->decisionmap[-l] <= 0)
+		break;
+	    }
+	  else
+	    {
+	      if (solv->decisionmap[l] > 0)
+		break;
+	      if (solv->decisionmap[l] == 0)
+		queue_push(dq, l);
+	    }
+	}
+      if (l || !dq->count)
+	continue;
+      /* prune to installed if not updating */
+      if (dq->count > 1 && solv->installed && !solv->updatemap_all &&
+	  !(solv->job.elements[solv->ruletojob.elements[i - solv->jobrules]] & SOLVER_ORUPDATE))
+	{
+	  int j, k;
+	  for (j = k = 0; j < dq->count; j++)
+	    {
+	      Solvable *s = pool->solvables + dq->elements[j];
+	      if (s->repo == solv->installed)
+		{
+		  dq->elements[k++] = dq->elements[j];
+		  if (solv->updatemap.size && MAPTST(&solv->updatemap, dq->elements[j] - solv->installed->start))
+		    {
+		      k = 0;	/* package wants to be updated, do not prune */
+		      break;
+		    }
+		}
+	    }
+	  if (k)
+	    dq->count = k;
+	}
+      olevel = level;
+      level = selectandinstall(solv, level, dq, disablerules, i, SOLVER_REASON_RESOLVE_JOB);
+      if (level <= olevel)
+	{
+	  if (level == olevel)
+	    {
+	      i--;
+	      r--;
+	      continue;	/* try something else */
+	    }
+	  if (level < oldlevel)
+	    return level;
+	  /* redo from start of jobrules */
+	  i = solv->jobrules - 1;
+	  r = solv->rules + i;
+	}
+    }
+  return level;
+}
+
+static int
+cleandeps_check_mistakes(Solver *solv)
 {
   Pool *pool = solv->pool;
   Rule *r;
@@ -1727,8 +1918,6 @@ cleandeps_check_mistakes(Solver *solv, int level)
       solver_reenablepolicyrules_cleandeps(solv, i);
       mademistake = 1;
     }
-  if (mademistake)
-    solver_reset(solv);
   return mademistake;
 }
 
@@ -1750,846 +1939,1098 @@ prune_to_update_targets(Solver *solv, Id *cp, Queue *q)
   queue_truncate(q, j);
 }
 
-/*-------------------------------------------------------------------
- *
- * solver_run_sat
- *
- * all rules have been set up, now actually run the solver
- *
- */
-
-void
-solver_run_sat(Solver *solv, int disablerules, int doweak)
+static int
+resolve_installed(Solver *solv, int level, int disablerules, Queue *dq)
 {
-  Queue dq;		/* local decisionqueue */
-  Queue dqs;		/* local decisionqueue for supplements */
-  int systemlevel;
-  int level, olevel;
-  Rule *r;
-  int i, j, n;
-  Solvable *s;
   Pool *pool = solv->pool;
-  Id p, pp, *dp;
-  int minimizationsteps;
-  int installedpos = solv->installed ? solv->installed->start : 0;
-
-  IF_POOLDEBUG (SOLV_DEBUG_RULE_CREATION)
-    {
-      POOL_DEBUG (SOLV_DEBUG_RULE_CREATION, "number of rules: %d\n", solv->nrules);
-      for (i = 1; i < solv->nrules; i++)
-	solver_printruleclass(solv, SOLV_DEBUG_RULE_CREATION, solv->rules + i);
-    }
-
-  POOL_DEBUG(SOLV_DEBUG_SOLVER, "initial decisions: %d\n", solv->decisionq.count);
-
-  /* start SAT algorithm */
-  level = 1;
-  systemlevel = level + 1;
-  POOL_DEBUG(SOLV_DEBUG_SOLVER, "solving...\n");
-
-  queue_init(&dq);
-  queue_init(&dqs);
-
-  /*
-   * here's the main loop:
-   * 1) propagate new decisions (only needed once)
-   * 2) fulfill jobs
-   * 3) try to keep installed packages
-   * 4) fulfill all unresolved rules
-   * 5) install recommended packages
-   * 6) minimalize solution if we had choices
-   * if we encounter a problem, we rewind to a safe level and restart
-   * with step 1
-   */
-
-  minimizationsteps = 0;
-  for (;;)
+  Repo *installed = solv->installed;
+  int i, n, pass;
+  int installedpos = solv->installedpos;
+  Solvable *s;
+  Id p, pp;
+  int olevel, origlevel = level;
+
+  POOL_DEBUG(SOLV_DEBUG_SOLVER, "resolving installed packages\n");
+  if (!installedpos)
+    installedpos = installed->start;
+  /* we use two passes if we need to update packages
+   * to create a better user experience */
+  for (pass = solv->updatemap.size ? 0 : 1; pass < 2; )
     {
-      /*
-       * initial propagation of the assertions
-       */
-      if (level == 1)
+      int passlevel = level;
+      Id *specialupdaters = solv->specialupdaters;
+      /* start with installedpos, the position that gave us problems the last time */
+      for (i = installedpos, n = installed->start; n < installed->end; i++, n++)
 	{
-	  POOL_DEBUG(SOLV_DEBUG_PROPAGATE, "propagating (propagate_index: %d;  size decisionq: %d)...\n", solv->propagate_index, solv->decisionq.count);
-	  if ((r = propagate(solv, level)) != 0)
-	    {
-	      if (analyze_unsolvable(solv, r, disablerules))
-		continue;
-	      level = 0;
-	      break;	/* unsolvable */
-	    }
-	}
+	  Rule *r, *rr;
+	  Id d;
 
-      /*
-       * resolve jobs first
-       */
-     if (level < systemlevel)
-	{
-	  POOL_DEBUG(SOLV_DEBUG_SOLVER, "resolving job rules\n");
-	  for (i = solv->jobrules, r = solv->rules + i; i < solv->jobrules_end; i++, r++)
+	  if (i == installed->end)
+	    i = installed->start;
+	  s = pool->solvables + i;
+	  if (s->repo != installed)
+	    continue;
+
+	  if (solv->decisionmap[i] > 0 && (!specialupdaters || !specialupdaters[i - installed->start]))
+	    continue;		/* already decided */
+	  if (!pass && solv->updatemap.size && !MAPTST(&solv->updatemap, i - installed->start))
+	    continue;		/* updates first */
+	  r = solv->rules + solv->updaterules + (i - installed->start);
+	  rr = r;
+	  if (!rr->p || rr->d < 0)	/* disabled -> look at feature rule */
+	    rr -= solv->installed->end - solv->installed->start;
+	  if (!rr->p)		/* identical to update rule? */
+	    rr = r;
+	  if (!rr->p)
+	    continue;		/* orpaned package or pseudo package */
+
+	  /* check if we should update this package to the latest version
+	   * noupdate is set for erase jobs, in that case we want to deinstall
+	   * the installed package and not replace it with a newer version
+	   * rr->p != i is for dup jobs where the installed package cannot be kept */
+	  if (dq->count)
+	    queue_empty(dq);
+	  if (!MAPTST(&solv->noupdate, i - installed->start) && (solv->decisionmap[i] < 0 || solv->updatemap_all || (solv->updatemap.size && MAPTST(&solv->updatemap, i - installed->start)) || (rr->p && rr->p != i)))
 	    {
-	      Id l;
-	      if (r->d < 0)		/* ignore disabled rules */
-		continue;
-	      queue_empty(&dq);
-	      FOR_RULELITERALS(l, pp, r)
+	      if (specialupdaters && (d = specialupdaters[i - installed->start]) != 0)
 		{
-		  if (l < 0)
-		    {
-		      if (solv->decisionmap[-l] <= 0)
-			break;
-		    }
-		  else
+		  /* special multiversion handling, make sure best version is chosen */
+		  if (rr->p == i && solv->decisionmap[i] >= 0)
+		    queue_push(dq, i);
+		  while ((p = pool->whatprovidesdata[d++]) != 0)
+		    if (solv->decisionmap[p] >= 0)
+		      queue_push(dq, p);
+		  if (dq->count && solv->update_targets && solv->update_targets->elements[i - installed->start])
+		    prune_to_update_targets(solv, solv->update_targets->elements + solv->update_targets->elements[i - installed->start], dq);
+		  if (dq->count)
 		    {
-		      if (solv->decisionmap[l] > 0)
-			break;
-		      if (solv->decisionmap[l] == 0)
-			queue_push(&dq, l);
+		      policy_filter_unwanted(solv, dq, POLICY_MODE_CHOOSE);
+		      p = dq->elements[0];
+		      if (p != i && solv->decisionmap[p] == 0)
+			{
+			  rr = solv->rules + solv->featurerules + (i - solv->installed->start);
+			  if (!rr->p)		/* update rule == feature rule? */
+			    rr = rr - solv->featurerules + solv->updaterules;
+			  dq->count = 1;
+			}
+		      else
+			dq->count = 0;
 		    }
 		}
-	      if (l || !dq.count)
-		continue;
-	      /* prune to installed if not updating */
-	      if (dq.count > 1 && solv->installed && !solv->updatemap_all &&
-		  !(solv->job.elements[solv->ruletojob.elements[i - solv->jobrules]] & SOLVER_ORUPDATE))
+	      else
 		{
-		  int j, k;
-		  for (j = k = 0; j < dq.count; j++)
+		  /* update to best package of the update rule */
+		  FOR_RULELITERALS(p, pp, rr)
 		    {
-		      Solvable *s = pool->solvables + dq.elements[j];
-		      if (s->repo == solv->installed)
+		      if (solv->decisionmap[p] > 0)
 			{
-			  dq.elements[k++] = dq.elements[j];
-			  if (solv->updatemap.size && MAPTST(&solv->updatemap, dq.elements[j] - solv->installed->start))
-			    {
-			      k = 0;	/* package wants to be updated, do not prune */
-			      break;
-			    }
+			  dq->count = 0;		/* already fulfilled */
+			  break;
 			}
+		      if (!solv->decisionmap[p])
+			queue_push(dq, p);
 		    }
-		  if (k)
-		    dq.count = k;
 		}
+	    }
+	  if (dq->count && solv->update_targets && solv->update_targets->elements[i - installed->start])
+	    prune_to_update_targets(solv, solv->update_targets->elements + solv->update_targets->elements[i - installed->start], dq);
+	  /* install best version */
+	  if (dq->count)
+	    {
 	      olevel = level;
-	      level = selectandinstall(solv, level, &dq, disablerules, i);
-	      if (level == 0)
-		break;
+	      level = selectandinstall(solv, level, dq, disablerules, rr - solv->rules, SOLVER_REASON_UPDATE_INSTALLED);
 	      if (level <= olevel)
-		break;
+		{
+		  if (level < passlevel)
+		    break;	/* trouble */
+		  if (level < olevel)
+		    n = installed->start;	/* redo all */
+		  i--;
+		  n--;
+		  continue;
+		}
 	    }
-          if (level == 0)
-	    break;	/* unsolvable */
-	  systemlevel = level + 1;
-	  if (i < solv->jobrules_end)
-	    continue;
-          if (!solv->decisioncnt_update)
-            solv->decisioncnt_update = solv->decisionq.count;
-	}
-
-      /*
-       * installed packages
-       */
-      if (level < systemlevel && solv->installed && solv->installed->nsolvables && !solv->installed->disabled)
-	{
-	  Repo *installed = solv->installed;
-	  int pass;
-
-	  POOL_DEBUG(SOLV_DEBUG_SOLVER, "resolving installed packages\n");
-	  /* we use two passes if we need to update packages
-           * to create a better user experience */
-	  for (pass = solv->updatemap.size ? 0 : 1; pass < 2; pass++)
+	  /* if still undecided keep package */
+	  if (solv->decisionmap[i] == 0)
 	    {
-	      int passlevel = level;
-	      Id *multiversionupdaters = solv->multiversion.size ? solv->multiversionupdaters : 0;
-	      if (pass == 1 && !solv->decisioncnt_keep)
-		solv->decisioncnt_keep = solv->decisionq.count;
-	      /* start with installedpos, the position that gave us problems the last time */
-	      for (i = installedpos, n = installed->start; n < installed->end; i++, n++)
+	      olevel = level;
+	      if (solv->cleandepsmap.size && MAPTST(&solv->cleandepsmap, i - installed->start))
 		{
-		  Rule *rr;
-		  Id d;
-
-		  if (i == installed->end)
-		    i = installed->start;
-		  s = pool->solvables + i;
-		  if (s->repo != installed)
-		    continue;
-
-		  if (solv->decisionmap[i] > 0 && (!multiversionupdaters || !multiversionupdaters[i - installed->start]))
-		    continue;		/* already decided */
-		  if (!pass && solv->updatemap.size && !MAPTST(&solv->updatemap, i - installed->start))
-		    continue;		/* updates first */
-		  r = solv->rules + solv->updaterules + (i - installed->start);
-		  rr = r;
-		  if (!rr->p || rr->d < 0)	/* disabled -> look at feature rule */
-		    rr -= solv->installed->end - solv->installed->start;
-		  if (!rr->p)		/* identical to update rule? */
-		    rr = r;
-		  if (!rr->p)
-		    continue;		/* orpaned package */
-
-		  /* check if we should update this package to the latest version
-		   * noupdate is set for erase jobs, in that case we want to deinstall
-		   * the installed package and not replace it with a newer version */
-		  queue_empty(&dq);
-		  if (!MAPTST(&solv->noupdate, i - installed->start) && (solv->decisionmap[i] < 0 || solv->updatemap_all || (solv->updatemap.size && MAPTST(&solv->updatemap, i - installed->start)) || rr->p != i))
-		    {
-		      if (multiversionupdaters && (d = multiversionupdaters[i - installed->start]) != 0)
-			{
-			  /* special multiversion handling, make sure best version is chosen */
-			  if (rr->p == i && solv->decisionmap[i] >= 0)
-			    queue_push(&dq, i);
-			  while ((p = pool->whatprovidesdata[d++]) != 0)
-			    if (solv->decisionmap[p] >= 0)
-			      queue_push(&dq, p);
-			  if (dq.count && solv->update_targets && solv->update_targets->elements[i - installed->start])
-			    prune_to_update_targets(solv, solv->update_targets->elements + solv->update_targets->elements[i - installed->start], &dq);
-			  if (dq.count)
-			    {
-			      policy_filter_unwanted(solv, &dq, POLICY_MODE_CHOOSE);
-			      p = dq.elements[0];
-			      if (p != i && solv->decisionmap[p] == 0)
-				{
-				  rr = solv->rules + solv->featurerules + (i - solv->installed->start);
-				  if (!rr->p)		/* update rule == feature rule? */
-				    rr = rr - solv->featurerules + solv->updaterules;
-				  dq.count = 1;
-				}
-			      else
-				dq.count = 0;
-			    }
-			}
-		      else
-			{
-			  /* update to best package of the update rule */
-			  FOR_RULELITERALS(p, pp, rr)
-			    {
-			      if (solv->decisionmap[p] > 0)
-				{
-				  dq.count = 0;		/* already fulfilled */
-				  break;
-				}
-			      if (!solv->decisionmap[p])
-				queue_push(&dq, p);
-			    }
-			}
-		    }
-		  if (dq.count && solv->update_targets && solv->update_targets->elements[i - installed->start])
-		    prune_to_update_targets(solv, solv->update_targets->elements + solv->update_targets->elements[i - installed->start], &dq);
-		  /* install best version */
-		  if (dq.count)
-		    {
-		      olevel = level;
-		      level = selectandinstall(solv, level, &dq, disablerules, rr - solv->rules);
-		      if (level == 0)
-			{
-			  queue_free(&dq);
-			  queue_free(&dqs);
-			  return;
-			}
-		      if (level <= olevel)
-			{
-			  if (level == 1 || level < passlevel)
-			    break;	/* trouble */
-			  if (level < olevel)
-			    n = installed->start;	/* redo all */
-			  i--;
-			  n--;
-			  continue;
-			}
-		    }
-		  /* if still undecided keep package */
-		  if (solv->decisionmap[i] == 0)
-		    {
-		      olevel = level;
-		      if (solv->cleandepsmap.size && MAPTST(&solv->cleandepsmap, i - installed->start))
-			{
 #if 0
-			  POOL_DEBUG(SOLV_DEBUG_POLICY, "cleandeps erasing %s\n", pool_solvid2str(pool, i));
-			  level = setpropagatelearn(solv, level, -i, disablerules, 0);
+		  POOL_DEBUG(SOLV_DEBUG_POLICY, "cleandeps erasing %s\n", pool_solvid2str(pool, i));
+		  level = setpropagatelearn(solv, level, -i, disablerules, 0, SOLVER_REASON_CLEANDEPS_ERASE);
 #else
-			  continue;
+		  continue;
 #endif
-			}
-		      else
-			{
-			  POOL_DEBUG(SOLV_DEBUG_POLICY, "keeping %s\n", pool_solvid2str(pool, i));
-			  level = setpropagatelearn(solv, level, i, disablerules, r - solv->rules);
-			}
-		      if (level == 0)
-			break;
-		      if (level <= olevel)
-			{
-			  if (level == 1 || level < passlevel)
-			    break;	/* trouble */
-			  if (level < olevel)
-			    n = installed->start;	/* redo all */
-			  i--;
-			  n--;
-			  continue;	/* retry with learnt rule */
-			}
-		    }
 		}
-	      if (n < installed->end)
+	      else
+		{
+		  POOL_DEBUG(SOLV_DEBUG_POLICY, "keeping %s\n", pool_solvid2str(pool, i));
+		  level = setpropagatelearn(solv, level, i, disablerules, r - solv->rules, SOLVER_REASON_KEEP_INSTALLED);
+		}
+	      if (level <= olevel)
 		{
-		  installedpos = i;	/* retry problem solvable next time */
-		  break;		/* ran into trouble */
+		  if (level < passlevel)
+		    break;	/* trouble */
+		  if (level < olevel)
+		    n = installed->start;	/* redo all */
+		  i--;
+		  n--;
+		  continue;	/* retry with learnt rule */
 		}
-	      installedpos = installed->start;	/* reset installedpos */
 	    }
-          if (level == 0)
-	    break;		/* unsolvable */
-	  systemlevel = level + 1;
-	  if (pass < 2)
-	    continue;		/* had trouble, retry */
 	}
-      if (!solv->decisioncnt_keep)
-	solv->decisioncnt_keep = solv->decisionq.count;
-
-      if (level < systemlevel)
-        systemlevel = level;
-
-      /*
-       * decide
-       */
-      if (!solv->decisioncnt_resolve)
-        solv->decisioncnt_resolve = solv->decisionq.count;
-      POOL_DEBUG(SOLV_DEBUG_POLICY, "deciding unresolved rules\n");
-      for (i = 1, n = 1; n < solv->nrules; i++, n++)
+      if (n < installed->end)
 	{
-	  if (i == solv->nrules)
-	    i = 1;
-	  r = solv->rules + i;
-	  if (r->d < 0)		/* ignore disabled rules */
+	  installedpos = i;	/* retry problem solvable next time */
+	  if (level < origlevel)
+	    break;		/* ran into trouble */
+	  /* re-run all passes */
+          pass = solv->updatemap.size ? 0 : 1;
+	  continue;
+	}
+      /* reset installedpos, advance to next pass */
+      installedpos = installed->start;
+      pass++;
+    }
+  solv->installedpos = installedpos;
+  return level;
+}
+
+static int
+resolve_dependencies(Solver *solv, int level, int disablerules, Queue *dq)
+{
+  Pool *pool = solv->pool;
+  int i, j, n;
+  int postponed;
+  Rule *r;
+  int origlevel = level;
+  Id p, *dp;
+
+  /*
+   * decide
+   */
+  POOL_DEBUG(SOLV_DEBUG_POLICY, "deciding unresolved rules\n");
+  postponed = 0;
+  for (i = 1, n = 1; ; i++, n++)
+    {
+      if (n >= solv->nrules)
+	{
+	  if (postponed <= 0)
+	    break;
+	  i = postponed;
+	  postponed = -1;
+	  n = 1;
+	}
+      if (i == solv->nrules)
+	i = 1;
+      r = solv->rules + i;
+      if (r->d < 0)		/* ignore disabled rules */
+	continue;
+      if (r->p < 0)		/* most common cases first */
+	{
+	  if (r->d == 0 || solv->decisionmap[-r->p] <= 0)
 	    continue;
-	  queue_empty(&dq);
-	  if (r->d == 0)
+	}
+      if (dq->count)
+	queue_empty(dq);
+      if (r->d == 0)
+	{
+	  /* binary or unary rule */
+	  /* need two positive undecided literals, r->p already checked above */
+	  if (r->w2 <= 0)
+	    continue;
+	  if (solv->decisionmap[r->p] || solv->decisionmap[r->w2])
+	    continue;
+	  queue_push(dq, r->p);
+	  queue_push(dq, r->w2);
+	}
+      else
+	{
+	  /* make sure that
+	   * all negative literals are installed
+	   * no positive literal is installed
+	   * i.e. the rule is not fulfilled and we
+	   * just need to decide on the positive literals
+	   * (decisionmap[-r->p] for the r->p < 0 case is already checked above)
+	   */
+	  if (r->p >= 0)
 	    {
-	      /* binary or unary rule */
-	      /* need two positive undecided literals */
-	      if (r->p < 0 || r->w2 <= 0)
-		continue;
-	      if (solv->decisionmap[r->p] || solv->decisionmap[r->w2])
+	      if (solv->decisionmap[r->p] > 0)
 		continue;
-	      queue_push(&dq, r->p);
-	      queue_push(&dq, r->w2);
+	      if (solv->decisionmap[r->p] == 0)
+		queue_push(dq, r->p);
 	    }
-	  else
+	  dp = pool->whatprovidesdata + r->d;
+	  while ((p = *dp++) != 0)
 	    {
-	      /* make sure that
-               * all negative literals are installed
-               * no positive literal is installed
-	       * i.e. the rule is not fulfilled and we
-               * just need to decide on the positive literals
-               */
-	      if (r->p < 0)
+	      if (p < 0)
 		{
-		  if (solv->decisionmap[-r->p] <= 0)
-		    continue;
+		  if (solv->decisionmap[-p] <= 0)
+		    break;
 		}
 	      else
 		{
-		  if (solv->decisionmap[r->p] > 0)
-		    continue;
-		  if (solv->decisionmap[r->p] == 0)
-		    queue_push(&dq, r->p);
+		  if (solv->decisionmap[p] > 0)
+		    break;
+		  if (solv->decisionmap[p] == 0)
+		    queue_push(dq, p);
 		}
-	      dp = pool->whatprovidesdata + r->d;
-	      while ((p = *dp++) != 0)
+	    }
+	  if (p)
+	    continue;
+	}
+      IF_POOLDEBUG (SOLV_DEBUG_PROPAGATE)
+	{
+	  POOL_DEBUG(SOLV_DEBUG_PROPAGATE, "unfulfilled ");
+	  solver_printruleclass(solv, SOLV_DEBUG_PROPAGATE, r);
+	}
+      /* dq->count < 2 cannot happen as this means that
+       * the rule is unit */
+      assert(dq->count > 1);
+
+      /* prune to cleandeps packages */
+      if (solv->cleandepsmap.size && solv->installed)
+	{
+	  Repo *installed = solv->installed;
+	  for (j = 0; j < dq->count; j++)
+	    if (pool->solvables[dq->elements[j]].repo == installed && MAPTST(&solv->cleandepsmap, dq->elements[j] - installed->start))
+	      break;
+	  if (j < dq->count)
+	    {
+	      dq->elements[0] = dq->elements[j];
+	      queue_truncate(dq, 1);
+	    }
+	}
+
+      if (dq->count > 1 && postponed >= 0)
+	{
+	  policy_filter_unwanted(solv, dq, POLICY_MODE_CHOOSE_NOREORDER);
+	  if (dq->count > 1)
+	    {
+	      if (!postponed)
+		postponed = i;
+	      continue;
+	    }
+	}
+
+      level = selectandinstall(solv, level, dq, disablerules, r - solv->rules, SOLVER_REASON_RESOLVE);
+      if (level < origlevel)
+	break;		/* trouble */
+      /* something changed, so look at all rules again */
+      n = 0;
+    }
+  return level;
+}
+
+
+#ifdef ENABLE_COMPLEX_DEPS
+
+static void
+add_complex_recommends(Solver *solv, Id rec, Queue *dq, Map *dqmap)
+{
+  Pool *pool = solv->pool;
+  int oldcnt = dq->count;
+  int cutcnt, blkcnt;
+  Id p;
+  int i, j;
+
+#if 0
+  printf("ADD_COMPLEX_RECOMMENDS %s\n", pool_dep2str(pool, rec));
+#endif
+  i = pool_normalize_complex_dep(pool, rec, dq, CPLXDEPS_EXPAND);
+  if (i == 0 || i == 1)
+    return;
+  cutcnt = dq->count;
+  for (i = oldcnt; i < cutcnt; i++)
+    {
+      blkcnt = dq->count;
+      for (; (p = dq->elements[i]) != 0; i++)
+	{
+	  if (p < 0)
+	    {
+	      if (solv->decisionmap[-p] <= 0)
+		break;
+	      continue;
+	    }
+	  if (solv->decisionmap[p] > 0)
+	    {
+	      queue_truncate(dq, blkcnt);
+	      break;
+	    }
+	  if (dqmap)
+	    {
+	      if (!MAPTST(dqmap, p))
+		continue;
+	    }
+	  else
+	    {
+	      if (solv->decisionmap[p] < 0)
+		continue;
+	      if (solv->dupmap_all && solv->installed && pool->solvables[p].repo == solv->installed && (solv->droporphanedmap_all || (solv->droporphanedmap.size && MAPTST(&solv->droporphanedmap, p - solv->installed->start))))
+		continue;
+	    }
+	  queue_push(dq, p);
+	}
+      while (dq->elements[i])
+	i++;
+    }
+  queue_deleten(dq, oldcnt, cutcnt - oldcnt);
+  /* unify */
+  if (dq->count != oldcnt)
+    {
+      for (j = oldcnt; j < dq->count; j++)
+	{
+	  p = dq->elements[j];
+	  for (i = 0; i < j; i++)
+	    if (dq->elements[i] == p)
+	      {
+		dq->elements[j] = 0;
+		break;
+	      }
+	}
+      for (i = j = oldcnt; j < dq->count; j++)
+	if (dq->elements[j])
+	  dq->elements[i++] = dq->elements[j];
+      queue_truncate(dq, i);
+    }
+#if 0
+  printf("RETURN:\n");
+  for (i = oldcnt; i < dq->count; i++)
+    printf("  - %s\n", pool_solvid2str(pool, dq->elements[i]));
+#endif
+}
+
+static void
+do_complex_recommendations(Solver *solv, Id rec, Map *m, int noselected)
+{
+  Pool *pool = solv->pool;
+  Queue dq;
+  Id p;
+  int i, blk;
+
+#if 0
+  printf("DO_COMPLEX_RECOMMENDATIONS %s\n", pool_dep2str(pool, rec));
+#endif
+  queue_init(&dq);
+  i = pool_normalize_complex_dep(pool, rec, &dq, CPLXDEPS_EXPAND);
+  if (i == 0 || i == 1)
+    {
+      queue_free(&dq);
+      return;
+    }
+  for (i = 0; i < dq.count; i++)
+    {
+      blk = i;
+      for (; (p = dq.elements[i]) != 0; i++)
+	{
+	  if (p < 0)
+	    {
+	      if (solv->decisionmap[-p] <= 0)
+		break;
+	      continue;
+	    }
+	  if (solv->decisionmap[p] > 0)
+	    {
+	      if (noselected)
+		break;
+	      MAPSET(m, p);
+	      for (i++; (p = dq.elements[i]) != 0; i++)
+		if (p > 0 && solv->decisionmap[p] > 0)
+		  MAPSET(m, p);
+	      p = 1;
+	      break;
+	    }
+	}
+      if (!p)
+	{
+	  for (i = blk; (p = dq.elements[i]) != 0; i++)
+	    if (p > 0)
+	      MAPSET(m, p);
+	}
+      while (dq.elements[i])
+	i++;
+    }
+  queue_free(&dq);
+}
+
+#endif
+
+static void
+prune_disfavored(Solver *solv, Queue *plist)
+{
+  int i, j;
+  if (!solv->isdisfavormap.size)
+    return;
+  for (i = j = 0; i < plist->count; i++) 
+    {    
+      Id p = plist->elements[i];
+      if (!MAPTST(&solv->isdisfavormap, p))
+        plist->elements[j++] = p; 
+    }    
+  if (i != j)
+    queue_truncate(plist, j);
+}
+
+static int
+resolve_weak(Solver *solv, int level, int disablerules, Queue *dq, Queue *dqs, int *rerunp)
+{
+  Pool *pool = solv->pool;
+  int i, j, qcount;
+  int olevel;
+  Solvable *s;
+  Map dqmap;
+  int decisioncount;
+  Id p;
+
+  POOL_DEBUG(SOLV_DEBUG_POLICY, "installing recommended packages\n");
+  if (dq->count)
+    queue_empty(dq);	/* recommended packages */
+  if (dqs->count)
+    queue_empty(dqs);	/* supplemented packages */
+  for (i = 1; i < pool->nsolvables; i++)
+    {
+      if (solv->decisionmap[i] < 0)
+	continue;
+      s = pool->solvables + i;
+      if (solv->decisionmap[i] > 0)
+	{
+	  /* installed, check for recommends */
+	  Id *recp, rec, pp, p;
+	  if (!solv->addalreadyrecommended && s->repo == solv->installed)
+	    continue;
+	  /* XXX need to special case AND ? */
+	  if (s->recommends)
+	    {
+	      recp = s->repo->idarraydata + s->recommends;
+	      while ((rec = *recp++) != 0)
 		{
-		  if (p < 0)
+#ifdef ENABLE_COMPLEX_DEPS
+		  if (pool_is_complex_dep(pool, rec))
 		    {
-		      if (solv->decisionmap[-p] <= 0)
-			break;
+		      add_complex_recommends(solv, rec, dq, 0);
+		      continue;
 		    }
-		  else
+#endif
+		  qcount = dq->count;
+		  FOR_PROVIDES(p, pp, rec)
 		    {
 		      if (solv->decisionmap[p] > 0)
-			break;
-		      if (solv->decisionmap[p] == 0)
-			queue_push(&dq, p);
+			{
+			  dq->count = qcount;
+			  break;
+			}
+		      else if (solv->decisionmap[p] == 0)
+			{
+			  if (solv->dupmap_all && solv->installed && pool->solvables[p].repo == solv->installed && (solv->droporphanedmap_all || (solv->droporphanedmap.size && MAPTST(&solv->droporphanedmap, p - solv->installed->start))))
+			    continue;
+			  queue_pushunique(dq, p);
+			}
 		    }
 		}
-	      if (p)
-		continue;
 	    }
-	  IF_POOLDEBUG (SOLV_DEBUG_PROPAGATE)
-	    {
-	      POOL_DEBUG(SOLV_DEBUG_PROPAGATE, "unfulfilled ");
-	      solver_printruleclass(solv, SOLV_DEBUG_PROPAGATE, r);
-	    }
-	  /* dq.count < 2 cannot happen as this means that
-	   * the rule is unit */
-	  assert(dq.count > 1);
+	}
+      else
+	{
+	  /* not yet installed, check if supplemented */
+	  if (!s->supplements)
+	    continue;
+	  if (!pool_installable(pool, s))
+	    continue;
+	  if (!solver_is_supplementing(solv, s))
+	    continue;
+	  if (solv->dupmap_all && solv->installed && s->repo == solv->installed && (solv->droporphanedmap_all || (solv->droporphanedmap.size && MAPTST(&solv->droporphanedmap, i - solv->installed->start))))
+	    continue;
+	  if (solv->isdisfavormap.size && MAPTST(&solv->isdisfavormap, i))
+	    continue;	/* disfavored supplements, do not install */
+	  queue_push(dqs, i);
+	}
+    }
 
-	  /* prune to cleandeps packages */
-	  if (solv->cleandepsmap.size && solv->installed)
+  /* filter out disfavored recommended packages */
+  if (dq->count && solv->isdisfavormap.size)
+    prune_disfavored(solv, dq);
+
+  /* filter out all packages obsoleted by installed packages */
+  /* this is no longer needed if we have (and trust) reverse obsoletes */
+  if ((dqs->count || dq->count) && solv->installed)
+    {
+      Map obsmap;
+      Id obs, *obsp, po, ppo;
+
+      map_init(&obsmap, pool->nsolvables);
+      for (p = solv->installed->start; p < solv->installed->end; p++)
+	{
+	  s = pool->solvables + p;
+	  if (s->repo != solv->installed || !s->obsoletes)
+	    continue;
+	  if (solv->decisionmap[p] <= 0)
+	    continue;
+	  if (!solv->keepexplicitobsoletes && solv->multiversion.size && MAPTST(&solv->multiversion, p))
+	    continue;
+	  obsp = s->repo->idarraydata + s->obsoletes;
+	  /* foreach obsoletes */
+	  while ((obs = *obsp++) != 0)
+	    FOR_PROVIDES(po, ppo, obs)
+	      {
+		Solvable *pos = pool->solvables + po;
+		if (!pool->obsoleteusesprovides && !pool_match_nevr(pool, pos, obs))
+		  continue;
+		if (pool->obsoleteusescolors && !pool_colormatch(pool, s, pos))
+		  continue;
+		MAPSET(&obsmap, po);
+	      }
+	}
+      for (i = j = 0; i < dqs->count; i++)
+	if (!MAPTST(&obsmap, dqs->elements[i]))
+	  dqs->elements[j++] = dqs->elements[i];
+      dqs->count = j;
+      for (i = j = 0; i < dq->count; i++)
+	if (!MAPTST(&obsmap, dq->elements[i]))
+	  dq->elements[j++] = dq->elements[i];
+      dq->count = j;
+      map_free(&obsmap);
+    }
+
+  /* filter out all already supplemented packages if requested */
+  if (!solv->addalreadyrecommended && dqs->count)
+    {
+      /* filter out old supplements */
+      for (i = j = 0; i < dqs->count; i++)
+	{
+	  p = dqs->elements[i];
+	  s = pool->solvables + p;
+	  if (s->supplements && solver_is_supplementing_alreadyinstalled(solv, s))
+	    dqs->elements[j++] = p;
+	}
+      dqs->count = j;
+    }
+
+  /* multiversion doesn't mix well with supplements.
+   * filter supplemented packages where we already decided
+   * to install a different version (see bnc#501088) */
+  if (dqs->count && solv->multiversion.size)
+    {
+      for (i = j = 0; i < dqs->count; i++)
+	{
+	  p = dqs->elements[i];
+	  if (MAPTST(&solv->multiversion, p))
 	    {
-	      Repo *installed = solv->installed;
-	      for (j = 0; j < dq.count; j++)
-		if (pool->solvables[dq.elements[j]].repo == installed && MAPTST(&solv->cleandepsmap, dq.elements[j] - installed->start))
+	      Id p2, pp2;
+	      s = pool->solvables + p;
+	      FOR_PROVIDES(p2, pp2, s->name)
+		if (solv->decisionmap[p2] > 0 && pool->solvables[p2].name == s->name)
 		  break;
-	      if (j < dq.count)
-		{
-		  dq.elements[0] = dq.elements[j];
-		  queue_truncate(&dq, 1);
-		}
+	      if (p2)
+		continue;	/* ignore this package */
 	    }
-
-	  olevel = level;
-	  level = selectandinstall(solv, level, &dq, disablerules, r - solv->rules);
-	  if (level == 0)
-	    break;		/* unsolvable */
-	  if (level < systemlevel || level == 1)
-	    break;		/* trouble */
-	  /* something changed, so look at all rules again */
-	  n = 0;
+	  dqs->elements[j++] = p;
 	}
+      dqs->count = j;
+    }
 
-      if (n != solv->nrules)	/* ran into trouble? */
+  /* implicitobsoleteusescolors doesn't mix well with supplements.
+   * filter supplemented packages where we already decided
+   * to install a different architecture */
+  if (dqs->count && pool->implicitobsoleteusescolors)
+    {
+      for (i = j = 0; i < dqs->count; i++)
 	{
-	  if (level == 0)
-	    break;		/* unsolvable */
-	  continue;		/* start over */
+	  Id p2, pp2;
+	  p = dqs->elements[i];
+	  s = pool->solvables + p;
+	  FOR_PROVIDES(p2, pp2, s->name)
+	    if (solv->decisionmap[p2] > 0 && pool->solvables[p2].name == s->name && pool->solvables[p2].arch != s->arch)
+	      break;
+	  if (p2)
+	    continue;	/* ignore this package */
+	  dqs->elements[j++] = p;
 	}
+      dqs->count = j;
+    }
 
-      /* at this point we have a consistent system. now do the extras... */
+  /* make dq contain both recommended and supplemented pkgs */
+  if (dqs->count)
+    {
+      for (i = 0; i < dqs->count; i++)
+	queue_pushunique(dq, dqs->elements[i]);
+    }
 
-      /* first decide leftover cleandeps packages */
-      if (solv->cleandepsmap.size && solv->installed)
+  if (!dq->count)
+    return level;
+  *rerunp = 1;
+
+  if (dq->count == 1)
+    {
+      /* simple case, just one package. no need to choose to best version */
+      p = dq->elements[0];
+      if (dqs->count)
+	POOL_DEBUG(SOLV_DEBUG_POLICY, "installing supplemented %s\n", pool_solvid2str(pool, p));
+      else
+	POOL_DEBUG(SOLV_DEBUG_POLICY, "installing recommended %s\n", pool_solvid2str(pool, p));
+      return setpropagatelearn(solv, level, p, 0, 0, SOLVER_REASON_WEAKDEP);
+    }
+
+  /* filter packages, this gives us the best versions */
+  policy_filter_unwanted(solv, dq, POLICY_MODE_RECOMMEND);
+
+  /* create map of result */
+  map_init(&dqmap, pool->nsolvables);
+  for (i = 0; i < dq->count; i++)
+    MAPSET(&dqmap, dq->elements[i]);
+
+  /* prune dqs so that it only contains the best versions */
+  for (i = j = 0; i < dqs->count; i++)
+    {
+      p = dqs->elements[i];
+      if (MAPTST(&dqmap, p))
+	dqs->elements[j++] = p;
+    }
+  dqs->count = j;
+
+  /* install all supplemented packages, but order first */
+  if (dqs->count > 1)
+    policy_filter_unwanted(solv, dqs, POLICY_MODE_SUPPLEMENT);
+  decisioncount = solv->decisionq.count;
+  for (i = 0; i < dqs->count; i++)
+    {
+      p = dqs->elements[i];
+      if (solv->decisionmap[p])
+	continue;
+      POOL_DEBUG(SOLV_DEBUG_POLICY, "installing supplemented %s\n", pool_solvid2str(pool, p));
+      olevel = level;
+      level = setpropagatelearn(solv, level, p, 0, 0, SOLVER_REASON_WEAKDEP);
+      if (level <= olevel)
+	break;
+    }
+  if (i < dqs->count || solv->decisionq.count < decisioncount)
+    {
+      map_free(&dqmap);
+      return level;
+    }
+
+  /* install all recommended packages */
+  /* more work as we want to created branches if multiple
+   * choices are valid */
+  for (i = 0; i < decisioncount; i++)
+    {
+      Id rec, *recp, pp;
+      p = solv->decisionq.elements[i];
+      if (p < 0)
+	continue;
+      s = pool->solvables + p;
+      if (!s->repo || (!solv->addalreadyrecommended && s->repo == solv->installed))
+	continue;
+      if (!s->recommends)
+	continue;
+      recp = s->repo->idarraydata + s->recommends;
+      while ((rec = *recp++) != 0)
 	{
-	  for (p = solv->installed->start; p < solv->installed->end; p++)
+	  queue_empty(dq);
+#ifdef ENABLE_COMPLEX_DEPS
+	  if (pool_is_complex_dep(pool, rec))
+	      add_complex_recommends(solv, rec, dq, &dqmap);
+	  else
+#endif
+	  FOR_PROVIDES(p, pp, rec)
 	    {
-	      s = pool->solvables + p;
-	      if (s->repo != solv->installed)
-		continue;
-	      if (solv->decisionmap[p] == 0 && MAPTST(&solv->cleandepsmap, p - solv->installed->start))
+	      if (solv->decisionmap[p] > 0)
 		{
-		  POOL_DEBUG(SOLV_DEBUG_POLICY, "cleandeps erasing %s\n", pool_solvid2str(pool, p));
-		  olevel = level;
-		  level = setpropagatelearn(solv, level, -p, 0, 0);
-		  if (level < olevel)
-		    break;
+		  dq->count = 0;
+		  break;
 		}
+	      else if (solv->decisionmap[p] == 0 && MAPTST(&dqmap, p))
+		queue_push(dq, p);
 	    }
-	  if (p < solv->installed->end)
+	  if (!dq->count)
 	    continue;
+	  if (dq->count > 1)
+	    policy_filter_unwanted(solv, dq, POLICY_MODE_CHOOSE);
+	  /* if we have multiple candidates we open a branch */
+	  if (dq->count > 1)
+	      createbranch(solv, level, dq, s - pool->solvables, rec);
+	  p = dq->elements[0];
+	  POOL_DEBUG(SOLV_DEBUG_POLICY, "installing recommended %s\n", pool_solvid2str(pool, p));
+	  olevel = level;
+	  level = setpropagatelearn(solv, level, p, 0, 0, SOLVER_REASON_WEAKDEP);
+	  if (level <= olevel || solv->decisionq.count < decisioncount)
+	    break;	/* we had to revert some decisions */
 	}
+      if (rec)
+	break;	/* had a problem above, quit loop */
+    }
+  map_free(&dqmap);
+  return level;
+}
 
-      if (!solv->decisioncnt_weak)
-        solv->decisioncnt_weak = solv->decisionq.count;
-      if (doweak)
-	{
-	  int qcount;
 
-	  POOL_DEBUG(SOLV_DEBUG_POLICY, "installing recommended packages\n");
-	  queue_empty(&dq);	/* recommended packages */
-	  queue_empty(&dqs);	/* supplemented packages */
-	  for (i = 1; i < pool->nsolvables; i++)
+static int
+resolve_orphaned(Solver *solv, int level, int disablerules, Queue *dq, int *rerunp)
+{
+  Pool *pool = solv->pool;
+  int i;
+  Id p;
+  int installedone = 0;
+  int olevel;
+
+  /* let's see if we can install some unsupported package */
+  POOL_DEBUG(SOLV_DEBUG_SOLVER, "deciding orphaned packages\n");
+  for (i = 0; i < solv->orphaned.count; i++)
+    {
+      p = solv->orphaned.elements[i];
+      if (solv->decisionmap[p])
+	continue;	/* already decided */
+      if (solv->droporphanedmap_all)
+	continue;
+      if (solv->droporphanedmap.size && MAPTST(&solv->droporphanedmap, p - solv->installed->start))
+	continue;
+      POOL_DEBUG(SOLV_DEBUG_SOLVER, "keeping orphaned %s\n", pool_solvid2str(pool, p));
+      olevel = level;
+      level = setpropagatelearn(solv, level, p, 0, 0, SOLVER_REASON_RESOLVE_ORPHAN);
+      installedone = 1;
+      if (level < olevel)
+	break;
+    }
+  if (installedone || i < solv->orphaned.count)
+    {
+      *rerunp = 1;
+      return level;
+    }
+  for (i = 0; i < solv->orphaned.count; i++)
+    {
+      p = solv->orphaned.elements[i];
+      if (solv->decisionmap[p])
+	continue;	/* already decided */
+      POOL_DEBUG(SOLV_DEBUG_SOLVER, "removing orphaned %s\n", pool_solvid2str(pool, p));
+      olevel = level;
+      level = setpropagatelearn(solv, level, -p, 0, 0, SOLVER_REASON_RESOLVE_ORPHAN);
+      if (level < olevel)
+	{
+	  *rerunp = 1;
+	  return level;
+	}
+    }
+  if (solv->brokenorphanrules)
+    {
+      solver_check_brokenorphanrules(solv, dq);
+      if (dq->count)
+	{
+	  policy_filter_unwanted(solv, dq, POLICY_MODE_CHOOSE);
+	  for (i = 0; i < dq->count; i++)
 	    {
-	      if (solv->decisionmap[i] < 0)
-		continue;
-	      if (solv->decisionmap[i] > 0)
-		{
-		  /* installed, check for recommends */
-		  Id *recp, rec, pp, p;
-		  s = pool->solvables + i;
-		  if (!solv->addalreadyrecommended && s->repo == solv->installed)
-		    continue;
-		  /* XXX need to special case AND ? */
-		  if (s->recommends)
-		    {
-		      recp = s->repo->idarraydata + s->recommends;
-		      while ((rec = *recp++) != 0)
-			{
-			  qcount = dq.count;
-			  FOR_PROVIDES(p, pp, rec)
-			    {
-			      if (solv->decisionmap[p] > 0)
-				{
-				  dq.count = qcount;
-				  break;
-				}
-			      else if (solv->decisionmap[p] == 0)
-				{
-				  if (solv->dupmap_all && solv->installed && pool->solvables[p].repo == solv->installed && (solv->droporphanedmap_all || (solv->droporphanedmap.size && MAPTST(&solv->droporphanedmap, p - solv->installed->start))))
-				    continue;
-				  queue_pushunique(&dq, p);
-				}
-			    }
-			}
-		    }
-		}
-	      else
-		{
-		  s = pool->solvables + i;
-		  if (!s->supplements)
-		    continue;
-		  if (!pool_installable(pool, s))
-		    continue;
-		  if (!solver_is_supplementing(solv, s))
-		    continue;
-		  if (solv->dupmap_all && solv->installed && s->repo == solv->installed && (solv->droporphanedmap_all || (solv->droporphanedmap.size && MAPTST(&solv->droporphanedmap, i - solv->installed->start))))
-		    continue;
-		  queue_push(&dqs, i);
-		}
+	      p = dq->elements[i];
+	      POOL_DEBUG(SOLV_DEBUG_POLICY, "installing orphaned dep %s\n", pool_solvid2str(pool, p));
+	      olevel = level;
+	      level = setpropagatelearn(solv, level, p, 0, 0, SOLVER_REASON_RESOLVE_ORPHAN);
+	      if (level < olevel)
+		break;
 	    }
+	  *rerunp = 1;
+	}
+    }
+  return level;
+}
+
+/*-------------------------------------------------------------------
+ *
+ * solver_run_sat
+ *
+ * all rules have been set up, now actually run the solver
+ *
+ */
+
+void
+solver_run_sat(Solver *solv, int disablerules, int doweak)
+{
+  Queue dq;		/* local decisionqueue */
+  Queue dqs;		/* local decisionqueue for supplements */
+  int systemlevel;
+  int level, olevel;
+  Rule *r;
+  int i;
+  Solvable *s;
+  Pool *pool = solv->pool;
+  Id p;
+  int minimizationsteps;
+
+  IF_POOLDEBUG (SOLV_DEBUG_RULE_CREATION)
+    {
+      POOL_DEBUG (SOLV_DEBUG_RULE_CREATION, "number of rules: %d\n", solv->nrules);
+      for (i = 1; i < solv->nrules; i++)
+	solver_printruleclass(solv, SOLV_DEBUG_RULE_CREATION, solv->rules + i);
+    }
+
+  /* start SAT algorithm */
+  level = 0;
+  systemlevel = level + 1;
+  POOL_DEBUG(SOLV_DEBUG_SOLVER, "solving...\n");
+
+  queue_init(&dq);
+  queue_init(&dqs);
+  solv->installedpos = 0;
+  solv->do_extra_reordering = 0;
+
+  /*
+   * here's the main loop:
+   * 1) decide assertion rules and propagate
+   * 2) fulfill jobs
+   * 3) try to keep installed packages
+   * 4) fulfill all unresolved rules
+   * 5) install recommended packages
+   * 6) minimalize solution if we had choices
+   * if we encounter a problem, we rewind to a safe level and restart
+   * with step 1
+   */
 
-	  /* filter out all packages obsoleted by installed packages */
-	  /* this is no longer needed if we have reverse obsoletes */
-          if ((dqs.count || dq.count) && solv->installed)
+  minimizationsteps = 0;
+  for (;;)
+    {
+      /*
+       * initial propagation of the assertions
+       */
+      if (level <= 0)
+	{
+	  if (level < 0)
+	    break;
+	  makeruledecisions(solv);
+	  level = 1;
+	  if (!disablerules && solv->problems.count)
 	    {
-	      Map obsmap;
-	      Id obs, *obsp, po, ppo;
-
-	      map_init(&obsmap, pool->nsolvables);
-	      for (p = solv->installed->start; p < solv->installed->end; p++)
-		{
-		  s = pool->solvables + p;
-		  if (s->repo != solv->installed || !s->obsoletes)
-		    continue;
-		  if (solv->decisionmap[p] <= 0)
-		    continue;
-		  if (solv->multiversion.size && MAPTST(&solv->multiversion, p))
-		    continue;
-		  obsp = s->repo->idarraydata + s->obsoletes;
-		  /* foreach obsoletes */
-		  while ((obs = *obsp++) != 0)
-		    FOR_PROVIDES(po, ppo, obs)
-		      MAPSET(&obsmap, po);
-		}
-	      for (i = j = 0; i < dqs.count; i++)
-		if (!MAPTST(&obsmap, dqs.elements[i]))
-		  dqs.elements[j++] = dqs.elements[i];
-	      dqs.count = j;
-	      for (i = j = 0; i < dq.count; i++)
-		if (!MAPTST(&obsmap, dq.elements[i]))
-		  dq.elements[j++] = dq.elements[i];
-	      dq.count = j;
-	      map_free(&obsmap);
+	      level = -1;
+	      break;
 	    }
-
-          /* filter out all already supplemented packages if requested */
-          if (!solv->addalreadyrecommended && dqs.count)
+	  POOL_DEBUG(SOLV_DEBUG_PROPAGATE, "initial propagate (propagate_index: %d;  size decisionq: %d)...\n", solv->propagate_index, solv->decisionq.count);
+	  if ((r = propagate(solv, level)) != 0)
 	    {
-	      int dosplitprovides_old = solv->dosplitprovides;
-	      /* turn off all new packages */
-	      for (i = 0; i < solv->decisionq.count; i++)
-		{
-		  p = solv->decisionq.elements[i];
-		  if (p < 0)
-		    continue;
-		  s = pool->solvables + p;
-		  if (s->repo && s->repo != solv->installed)
-		    solv->decisionmap[p] = -solv->decisionmap[p];
-		}
-	      solv->dosplitprovides = 0;
-	      /* filter out old supplements */
-	      for (i = j = 0; i < dqs.count; i++)
-		{
-		  p = dqs.elements[i];
-		  s = pool->solvables + p;
-		  if (!s->supplements)
-		    continue;
-		  if (!solver_is_supplementing(solv, s))
-		    dqs.elements[j++] = p;
-		  else if (solv->installsuppdepq && solver_check_installsuppdepq(solv, s))
-		    dqs.elements[j++] = p;
-		}
-	      dqs.count = j;
-	      /* undo turning off */
-	      for (i = 0; i < solv->decisionq.count; i++)
-		{
-		  p = solv->decisionq.elements[i];
-		  if (p < 0)
-		    continue;
-		  s = pool->solvables + p;
-		  if (s->repo && s->repo != solv->installed)
-		    solv->decisionmap[p] = -solv->decisionmap[p];
-		}
-	      solv->dosplitprovides = dosplitprovides_old;
+	      level = analyze_unsolvable(solv, r, disablerules);
+	      continue;
 	    }
+	  systemlevel = level + 1;
+	}
 
-	  /* multiversion doesn't mix well with supplements.
-	   * filter supplemented packages where we already decided
-	   * to install a different version (see bnc#501088) */
-          if (dqs.count && solv->multiversion.size)
-	    {
-	      for (i = j = 0; i < dqs.count; i++)
-		{
-		  p = dqs.elements[i];
-		  if (MAPTST(&solv->multiversion, p))
-		    {
-		      Id p2, pp2;
-		      s = pool->solvables + p;
-		      FOR_PROVIDES(p2, pp2, s->name)
-			if (solv->decisionmap[p2] > 0 && pool->solvables[p2].name == s->name)
-			  break;
-		      if (p2)
-			continue;	/* ignore this package */
-		    }
-		  dqs.elements[j++] = p;
-		}
-	      dqs.count = j;
-	    }
+      /*
+       * resolve jobs first (unless focus_installed is set)
+       */
+     if (level < systemlevel && !solv->focus_installed)
+	{
+	  if (solv->installed && solv->installed->nsolvables && !solv->installed->disabled)
+	    solv->do_extra_reordering = 1;
+	  olevel = level;
+	  level = resolve_jobrules(solv, level, disablerules, &dq);
+	  solv->do_extra_reordering = 0;
+	  if (level < olevel)
+	    continue;
+	  systemlevel = level + 1;
+	}
 
-          /* make dq contain both recommended and supplemented pkgs */
-	  if (dqs.count)
-	    {
-	      for (i = 0; i < dqs.count; i++)
-		queue_pushunique(&dq, dqs.elements[i]);
-	    }
+      /* resolve job dependencies in the focus_best case */
+      if (level < systemlevel && solv->focus_best && !solv->focus_installed && solv->installed && solv->installed->nsolvables && !solv->installed->disabled)
+	{
+	  solv->do_extra_reordering = 1;
+	  olevel = level;
+	  level = resolve_dependencies(solv, level, disablerules, &dq);
+	  solv->do_extra_reordering = 0;
+	  if (level < olevel)
+	    continue;		/* start over */
+	  systemlevel = level + 1;
+	}
 
-	  if (dq.count)
-	    {
-	      Map dqmap;
-	      int decisioncount = solv->decisionq.count;
+      /*
+       * installed packages
+       */
+      if (level < systemlevel && solv->installed && solv->installed->nsolvables && !solv->installed->disabled)
+	{
+	  olevel = level;
+	  level = resolve_installed(solv, level, disablerules, &dq);
+	  if (level < olevel)
+	    continue;
+	  systemlevel = level + 1;
+	}
 
-	      if (dq.count == 1)
-		{
-		  /* simple case, just one package. no need to choose to best version */
-		  p = dq.elements[0];
-		  if (dqs.count)
-		    POOL_DEBUG(SOLV_DEBUG_POLICY, "installing supplemented %s\n", pool_solvid2str(pool, p));
-		  else
-		    POOL_DEBUG(SOLV_DEBUG_POLICY, "installing recommended %s\n", pool_solvid2str(pool, p));
-		  level = setpropagatelearn(solv, level, p, 0, 0);
-		  if (level == 0)
-		    break;
-		  continue;	/* back to main loop */
-		}
+     /* resolve jobs in focus_installed case */
+     if (level < systemlevel && solv->focus_installed)
+	{
+	  olevel = level;
+	  level = resolve_jobrules(solv, level, disablerules, &dq);
+	  if (level < olevel)
+	    continue;
+	  systemlevel = level + 1;
+	}
 
-	      /* filter packages, this gives us the best versions */
-	      policy_filter_unwanted(solv, &dq, POLICY_MODE_RECOMMEND);
+      if (level < systemlevel)
+        systemlevel = level;
 
-	      /* create map of result */
-	      map_init(&dqmap, pool->nsolvables);
-	      for (i = 0; i < dq.count; i++)
-		MAPSET(&dqmap, dq.elements[i]);
+      /* resolve all dependencies */
+      olevel = level;
+      level = resolve_dependencies(solv, level, disablerules, &dq);
+      if (level < olevel)
+        continue;		/* start over */
 
-	      /* install all supplemented packages */
-	      for (i = 0; i < dqs.count; i++)
-		{
-		  p = dqs.elements[i];
-		  if (solv->decisionmap[p] || !MAPTST(&dqmap, p))
-		    continue;
-		  POOL_DEBUG(SOLV_DEBUG_POLICY, "installing supplemented %s\n", pool_solvid2str(pool, p));
-		  olevel = level;
-		  level = setpropagatelearn(solv, level, p, 0, 0);
-		  if (level <= olevel)
-		    break;
-		}
-	      if (i < dqs.count || solv->decisionq.count < decisioncount)
-		{
-		  map_free(&dqmap);
-		  if (level == 0)
-		    break;
-		  continue;
-		}
+      /* decide leftover cleandeps packages */
+      if (solv->cleandepsmap.size && solv->installed)
+       {
+         for (p = solv->installed->start; p < solv->installed->end; p++)
+           {
+             s = pool->solvables + p;
+             if (s->repo != solv->installed)
+               continue;
+             if (solv->decisionmap[p] == 0 && MAPTST(&solv->cleandepsmap, p - solv->installed->start))
+               {
+                 POOL_DEBUG(SOLV_DEBUG_POLICY, "cleandeps erasing %s\n", pool_solvid2str(pool, p));
+                 olevel = level;
+                 level = setpropagatelearn(solv, level, -p, 0, 0, SOLVER_REASON_CLEANDEPS_ERASE);
+                 if (level < olevel)
+                   break;
+               }
+           }
+         if (p < solv->installed->end)
+           continue;
+       }
 
-	      /* install all recommended packages */
-	      /* more work as we want to created branches if multiple
-               * choices are valid */
-	      for (i = 0; i < decisioncount; i++)
-		{
-		  Id rec, *recp, pp;
-		  p = solv->decisionq.elements[i];
-		  if (p < 0)
-		    continue;
-		  s = pool->solvables + p;
-		  if (!s->repo || (!solv->addalreadyrecommended && s->repo == solv->installed))
-		    continue;
-		  if (!s->recommends)
-		    continue;
-		  recp = s->repo->idarraydata + s->recommends;
-		  while ((rec = *recp++) != 0)
-		    {
-		      queue_empty(&dq);
-		      FOR_PROVIDES(p, pp, rec)
-			{
-			  if (solv->decisionmap[p] > 0)
-			    {
-			      dq.count = 0;
-			      break;
-			    }
-			  else if (solv->decisionmap[p] == 0 && MAPTST(&dqmap, p))
-			    queue_pushunique(&dq, p);
-			}
-		      if (!dq.count)
-			continue;
-		      if (dq.count > 1)
-			{
-			  /* multiple candidates, open a branch */
-			  for (i = 1; i < dq.count; i++)
-			    queue_push(&solv->branches, dq.elements[i]);
-			  queue_push(&solv->branches, -level);
-			}
-		      p = dq.elements[0];
-		      POOL_DEBUG(SOLV_DEBUG_POLICY, "installing recommended %s\n", pool_solvid2str(pool, p));
-		      olevel = level;
-		      level = setpropagatelearn(solv, level, p, 0, 0);
-		      if (level <= olevel || solv->decisionq.count < decisioncount)
-			break;	/* we had to revert some decisions */
-		    }
-		  if (rec)
-		    break;	/* had a problem above, quit loop */
-		}
-	      map_free(&dqmap);
-	      if (level == 0)
-		break;
-	      continue;		/* back to main loop so that all deps are checked */
-	    }
-	}
+      /* at this point we have a consistent system. now do the extras... */
 
-      if (!solv->decisioncnt_orphan)
-        solv->decisioncnt_orphan = solv->decisionq.count;
-      if (solv->dupmap_all && solv->installed)
+      if (doweak)
 	{
-	  int installedone = 0;
+	  int rerun = 0;
+	  level = resolve_weak(solv, level, disablerules, &dq, &dqs, &rerun);
+	  if (rerun)
+	    continue;
+	}
 
-	  /* let's see if we can install some unsupported package */
-	  POOL_DEBUG(SOLV_DEBUG_SOLVER, "deciding orphaned packages\n");
-	  for (i = 0; i < solv->orphaned.count; i++)
+      if (solv->installed && (solv->orphaned.count || solv->brokenorphanrules))
+	{
+	  int rerun = 0;
+	  level = resolve_orphaned(solv, level, disablerules, &dq, &rerun);
+	  if (rerun)
+	    continue;
+	}
+	  
+     /* one final pass to make sure we decided all installed packages */
+      if (solv->installed)
+	{
+	  for (p = solv->installed->start; p < solv->installed->end; p++)
 	    {
-	      p = solv->orphaned.elements[i];
 	      if (solv->decisionmap[p])
 		continue;	/* already decided */
-	      if (solv->droporphanedmap_all)
-		continue;
-	      if (solv->droporphanedmap.size && MAPTST(&solv->droporphanedmap, p - solv->installed->start))
+	      s = pool->solvables + p;
+	      if (s->repo != solv->installed)
 		continue;
-	      POOL_DEBUG(SOLV_DEBUG_SOLVER, "keeping orphaned %s\n", pool_solvid2str(pool, p));
-	      olevel = level;
-	      level = setpropagatelearn(solv, level, p, 0, 0);
-	      installedone = 1;
-	      if (level < olevel)
-		break;
-	    }
-	  if (installedone || i < solv->orphaned.count)
-	    {
-	      if (level == 0)
-		break;
-	      continue;		/* back to main loop */
-	    }
-	  for (i = 0; i < solv->orphaned.count; i++)
-	    {
-	      p = solv->orphaned.elements[i];
-	      if (solv->decisionmap[p])
-		continue;	/* already decided */
-	      POOL_DEBUG(SOLV_DEBUG_SOLVER, "removing orphaned %s\n", pool_solvid2str(pool, p));
+	      POOL_DEBUG(SOLV_DEBUG_SOLVER, "removing unwanted %s\n", pool_solvid2str(pool, p));
 	      olevel = level;
-	      level = setpropagatelearn(solv, level, -p, 0, 0);
+	      level = setpropagatelearn(solv, level, -p, 0, 0, SOLVER_REASON_CLEANDEPS_ERASE);
 	      if (level < olevel)
 		break;
 	    }
-	  if (i < solv->orphaned.count)
-	    {
-	      if (level == 0)
-		break;
-	      continue;		/* back to main loop */
-	    }
+	  if (p < solv->installed->end)
+	    continue;		/* back to main loop */
 	}
 
-     if (solv->installed && solv->cleandepsmap.size)
+      if (solv->installed && solv->cleandepsmap.size && cleandeps_check_mistakes(solv))
 	{
-	  if (cleandeps_check_mistakes(solv, level))
-	    {
-	      level = 1;	/* restart from scratch */
-	      systemlevel = level + 1;
-	      continue;
-	    }
+	  solver_reset(solv);
+	  level = 0;	/* restart from scratch */
+	  continue;
 	}
 
-     if (solv->solution_callback)
+      if (solv->solution_callback)
 	{
 	  solv->solution_callback(solv, solv->solution_callback_data);
 	  if (solv->branches.count)
 	    {
-	      int i = solv->branches.count - 1;
-	      int l = -solv->branches.elements[i];
-	      Id why;
-
-	      for (; i > 0; i--)
-		if (solv->branches.elements[i - 1] < 0)
-		  break;
-	      p = solv->branches.elements[i];
-	      POOL_DEBUG(SOLV_DEBUG_SOLVER, "branching with %s\n", pool_solvid2str(pool, p));
-	      queue_empty(&dq);
-	      for (j = i + 1; j < solv->branches.count; j++)
-		queue_push(&dq, solv->branches.elements[j]);
-	      solv->branches.count = i;
-	      level = l;
-	      revert(solv, level);
-	      if (dq.count > 1)
-	        for (j = 0; j < dq.count; j++)
-		  queue_push(&solv->branches, dq.elements[j]);
-	      olevel = level;
-	      why = -solv->decisionq_why.elements[solv->decisionq_why.count];
-	      assert(why >= 0);
-	      level = setpropagatelearn(solv, level, p, disablerules, why);
-	      if (level == 0)
-		break;
-	      continue;
+	      int l, endi = 0;
+	      p = l = 0;
+	      for (i = solv->branches.count - 1; i >= 0; i--)
+		{
+		  p = solv->branches.elements[i];
+		  if (p > 0 && !l)
+		    {
+		      endi = i + 1;
+		      l = p;
+		      i -= 3;	/* skip: p data count */
+		    }
+		  else if (p > 0)
+		    break;
+		  else if (p < 0)
+		    l = 0;
+		}
+	      if (i >= 0)
+		{
+		  while (i > 0 && solv->branches.elements[i - 1] > 0)
+		    i--;
+		  level = takebranch(solv, i, endi, "branching", disablerules);
+		  continue;
+		}
 	    }
 	  /* all branches done, we're finally finished */
 	  break;
 	}
 
       /* auto-minimization step */
-     if (solv->branches.count)
+      if (solv->branches.count)
 	{
-	  int l = 0, lasti = -1, lastl = -1;
-	  Id why;
-
-	  p = 0;
-	  for (i = solv->branches.count - 1; i >= 0; i--)
+	  int endi, lasti = -1, lastiend = -1;
+	  if (solv->recommends_index < solv->decisionq.count)
+	    policy_update_recommendsmap(solv);
+	  for (endi = solv->branches.count; endi > 0;)
 	    {
-	      p = solv->branches.elements[i];
-	      if (p < 0)
-		l = -p;
-	      else if (p > 0 && solv->decisionmap[p] > l + 1)
+	      int l, lastsi = -1, starti = endi - solv->branches.elements[endi - 2];
+	      l = solv->branches.elements[endi - 1];
+	      for (i = starti; i < endi - 4; i++)
 		{
-		  lasti = i;
-		  lastl = l;
+		  p = solv->branches.elements[i];
+		  if (p <= 0)
+		    continue;
+		  if (solv->decisionmap[p] > l)
+		    {
+		      lasti = i;
+		      lastiend = endi;
+		      lastsi = -1;
+		      break;
+		    }
+		  if (solv->isdisfavormap.size && MAPTST(&solv->isdisfavormap, p))
+		    continue;
+		  if (lastsi < 0 && (MAPTST(&solv->recommendsmap, p) || solver_is_supplementing(solv, pool->solvables + p)))
+		    lastsi = i;
+		}
+	      if (lastsi >= 0)
+		{
+		  /* we have a recommended package that could not be installed */
+		  /* take it if our current selection is not recommended */
+		  for (i = starti; i < endi - 4; i++)
+		    {
+		      p = -solv->branches.elements[i];
+		      if (p <= 0 || solv->decisionmap[p] != l + 1)
+			continue;
+		      if (solv->favormap.size && MAPTST(&solv->favormap, p))
+			if (!(solv->isdisfavormap.size && MAPTST(&solv->isdisfavormap, p)))
+			  continue;	/* current selection is favored */
+		      if (!(MAPTST(&solv->recommendsmap, p) || solver_is_supplementing(solv, pool->solvables + p)))
+			{
+			  lasti = lastsi;
+			  lastiend = endi;
+			  break;
+			}
+		    }
 		}
+	      endi = starti;
 	    }
 	  if (lasti >= 0)
 	    {
-	      /* kill old solvable so that we do not loop */
-	      p = solv->branches.elements[lasti];
-	      solv->branches.elements[lasti] = 0;
-	      POOL_DEBUG(SOLV_DEBUG_SOLVER, "minimizing %d -> %d with %s\n", solv->decisionmap[p], lastl, pool_solvid2str(pool, p));
 	      minimizationsteps++;
-
-	      level = lastl;
-	      revert(solv, level);
-	      why = -solv->decisionq_why.elements[solv->decisionq_why.count];
-	      assert(why >= 0);
-	      olevel = level;
-	      level = setpropagatelearn(solv, level, p, disablerules, why);
-	      if (level == 0)
-		break;
+	      level = takebranch(solv, lasti, lastiend, "minimizing", disablerules);
 	      continue;		/* back to main loop */
 	    }
 	}
       /* no minimization found, we're finally finished! */
       break;
     }
+  assert(level == -1 || level + 1 == solv->decisionq_reason.count);
 
   POOL_DEBUG(SOLV_DEBUG_STATS, "solver statistics: %d learned rules, %d unsolvable, %d minimization steps\n", solv->stats_learned, solv->stats_unsolvable, minimizationsteps);
 
   POOL_DEBUG(SOLV_DEBUG_STATS, "done solving.\n\n");
   queue_free(&dq);
   queue_free(&dqs);
-  if (level == 0)
-    {
-      /* unsolvable */
-      solv->decisioncnt_update = solv->decisionq.count;
-      solv->decisioncnt_keep = solv->decisionq.count;
-      solv->decisioncnt_resolve = solv->decisionq.count;
-      solv->decisioncnt_weak = solv->decisionq.count;
-      solv->decisioncnt_orphan = solv->decisionq.count;
-    }
 #if 0
   solver_printdecisionq(solv, SOLV_DEBUG_RESULT);
 #endif
@@ -2725,7 +3166,7 @@ weaken_solvable_deps(Solver *solv, Id p)
   int i;
   Rule *r;
 
-  for (i = 1, r = solv->rules + i; i < solv->rpmrules_end; i++, r++)
+  for (i = 1, r = solv->rules + i; i < solv->pkgrules_end; i++, r++)
     {
       if (r->p != -p)
 	continue;
@@ -2765,8 +3206,10 @@ solver_calculate_multiversionmap(Pool *pool, Queue *job, Map *multiversionmap)
 	  Solvable *s;
 	  Repo *repo = pool_id2repo(pool, what);
 	  if (repo)
-	    FOR_REPO_SOLVABLES(repo, p, s)
-	      MAPSET(multiversionmap, p);
+	    {
+	      FOR_REPO_SOLVABLES(repo, p, s)
+	        MAPSET(multiversionmap, p);
+	    }
 	}
       FOR_JOB_SELECT(p, pp, select, what)
         MAPSET(multiversionmap, p);
@@ -2783,9 +3226,9 @@ solver_calculate_noobsmap(Pool *pool, Queue *job, Map *multiversionmap)
  * add a rule created by a job, record job number and weak flag
  */
 static inline void
-solver_addjobrule(Solver *solv, Id p, Id d, Id job, int weak)
+solver_addjobrule(Solver *solv, Id p, Id p2, Id d, Id job, int weak)
 {
-  solver_addrule(solv, p, d);
+  solver_addrule(solv, p, p2, d);
   queue_push(&solv->ruletojob, job);
   if (weak)
     queue_push(&solv->weakruleq, solv->nrules - 1);
@@ -2927,7 +3370,7 @@ addedmap2deduceq(Solver *solv, Map *addedmap)
   Rule *r;
 
   queue_empty(&solv->addedmap_deduceq);
-  for (i = 2, j = solv->rpmrules_end - 1; i < pool->nsolvables && j > 0; j--)
+  for (i = 2, j = solv->pkgrules_end - 1; i < pool->nsolvables && j > 0; j--)
     {
       r = solv->rules + j;
       if (r->p >= 0)
@@ -2963,7 +3406,7 @@ deduceq2addedmap(Solver *solv, Map *addedmap)
   int j;
   Id p;
   Rule *r;
-  for (j = solv->rpmrules_end - 1; j > 0; j--)
+  for (j = solv->pkgrules_end - 1; j > 0; j--)
     {
       r = solv->rules + j;
       if (r->d < 0 && r->p)
@@ -2985,6 +3428,75 @@ deduceq2addedmap(Solver *solv, Map *addedmap)
     }
 }
 
+#ifdef ENABLE_COMPLEX_DEPS
+static int
+add_complex_jobrules(Solver *solv, Id dep, int flags, int jobidx, int weak)
+{
+  Pool *pool = solv->pool;
+  Queue bq;
+  int i, j;
+
+  queue_init(&bq);
+  i = pool_normalize_complex_dep(pool, dep, &bq, flags | CPLXDEPS_EXPAND);
+  if (i == 0 || i == 1)
+    {
+      queue_free(&bq);
+      if (i == 0)
+        solver_addjobrule(solv, -SYSTEMSOLVABLE, 0, 0, jobidx, weak);
+      return 0;
+    }
+  for (i = 0; i < bq.count; i++)
+    {
+      if (!bq.elements[i])
+	continue;
+      for (j = 0; bq.elements[i + j + 1]; j++)
+        ;
+      if (j > 1)
+        solver_addjobrule(solv, bq.elements[i], 0, pool_ids2whatprovides(pool, bq.elements + i + 1, j), jobidx, weak);
+      else
+        solver_addjobrule(solv, bq.elements[i], bq.elements[i + 1], 0, jobidx, weak);
+      i += j + 1;
+    }
+  queue_free(&bq);
+  return 1;
+}
+#endif
+
+/* sort by package id, last entry wins */
+static int
+setup_favormaps_cmp(const void *ap, const void *bp, void *dp)
+{
+  const Id *a = ap, *b = bp;
+  if ((*a - *b) != 0)
+    return *a - *b;
+  return (b[1] < 0 ? -b[1] : b[1]) - (a[1] < 0 ? -a[1] : a[1]);
+}
+
+static void
+setup_favormaps(Solver *solv)
+{
+  Queue *q = solv->favorq;
+  Pool *pool = solv->pool;
+  int i;
+  Id oldp = 0;
+  if (q->count > 2)
+    solv_sort(q->elements, q->count / 2, 2 * sizeof(Id), setup_favormaps_cmp, solv);
+  map_grow(&solv->favormap, pool->nsolvables);
+  for (i = 0; i < q->count; i += 2)
+    {
+      Id p = q->elements[i];
+      if (p == oldp)
+	continue;
+      oldp = p;
+      MAPSET(&solv->favormap, p);
+      if (q->elements[i + 1] < 0)
+	{
+	  if (!solv->isdisfavormap.size)
+	    map_grow(&solv->isdisfavormap, pool->nsolvables);
+	  MAPSET(&solv->isdisfavormap, p);
+	}
+    }
+}
 
 /*
  *
@@ -2999,14 +3511,14 @@ solver_solve(Solver *solv, Queue *job)
   Repo *installed = solv->installed;
   int i;
   int oldnrules, initialnrules;
-  Map addedmap;		       /* '1' == have rpm-rules for solvable */
+  Map addedmap;		       /* '1' == have pkg-rules for solvable */
   Map installcandidatemap;
   Id how, what, select, name, weak, p, pp, d;
   Queue q;
   Solvable *s;
   Rule *r;
   int now, solve_start;
-  int hasdupjob = 0;
+  int needduprules = 0;
   int hasbestinstalljob = 0;
 
   solve_start = solv_timems(0);
@@ -3034,73 +3546,33 @@ solver_solve(Solver *solv, Queue *job)
     queue_insertn(&solv->job, 0, pool->pooljobs.count, pool->pooljobs.elements);
   job = &solv->job;
 
-  /* free old stuff */
-  if (solv->update_targets)
-    {
-      queue_free(solv->update_targets);
-      solv->update_targets = solv_free(solv->update_targets);
-    }
-  if (solv->cleandeps_updatepkgs)
-    {
-      queue_free(solv->cleandeps_updatepkgs);
-      solv->cleandeps_updatepkgs = solv_free(solv->cleandeps_updatepkgs);
-    }
+  /* free old stuff in jase we re-run a solver */
+  queuep_free(&solv->update_targets);
+  queuep_free(&solv->cleandeps_updatepkgs);
   queue_empty(&solv->ruleassertions);
   solv->bestrules_pkg = solv_free(solv->bestrules_pkg);
+  solv->yumobsrules_info = solv_free(solv->yumobsrules_info);
   solv->choicerules_ref = solv_free(solv->choicerules_ref);
   if (solv->noupdate.size)
     map_empty(&solv->noupdate);
-  if (solv->multiversion.size)
-    {
-      map_free(&solv->multiversion);
-      map_init(&solv->multiversion, 0);
-    }
+  map_zerosize(&solv->multiversion);
   solv->updatemap_all = 0;
-  if (solv->updatemap.size)
-    {
-      map_free(&solv->updatemap);
-      map_init(&solv->updatemap, 0);
-    }
+  map_zerosize(&solv->updatemap);
   solv->bestupdatemap_all = 0;
-  if (solv->bestupdatemap.size)
-    {
-      map_free(&solv->bestupdatemap);
-      map_init(&solv->bestupdatemap, 0);
-    }
+  map_zerosize(&solv->bestupdatemap);
   solv->fixmap_all = 0;
-  if (solv->fixmap.size)
-    {
-      map_free(&solv->fixmap);
-      map_init(&solv->fixmap, 0);
-    }
+  map_zerosize(&solv->fixmap);
   solv->dupmap_all = 0;
-  if (solv->dupmap.size)
-    {
-      map_free(&solv->dupmap);
-      map_init(&solv->dupmap, 0);
-    }
-  if (solv->dupinvolvedmap.size)
-    {
-      map_free(&solv->dupinvolvedmap);
-      map_init(&solv->dupinvolvedmap, 0);
-    }
+  map_zerosize(&solv->dupmap);
+  map_zerosize(&solv->dupinvolvedmap);
   solv->droporphanedmap_all = 0;
-  if (solv->droporphanedmap.size)
-    {
-      map_free(&solv->droporphanedmap);
-      map_init(&solv->droporphanedmap, 0);
-    }
-  if (solv->cleandepsmap.size)
-    {
-      map_free(&solv->cleandepsmap);
-      map_init(&solv->cleandepsmap, 0);
-    }
-  if (solv->weakrulemap.size)
-    {
-      map_free(&solv->weakrulemap);
-      map_init(&solv->weakrulemap, 0);
-    }
-
+  map_zerosize(&solv->droporphanedmap);
+  solv->allowuninstall_all = 0;
+  map_zerosize(&solv->allowuninstallmap);
+  map_zerosize(&solv->cleandepsmap);
+  map_zerosize(&solv->weakrulemap);
+  map_zerosize(&solv->favormap);
+  map_zerosize(&solv->isdisfavormap);
   queue_empty(&solv->weakruleq);
   solv->watches = solv_free(solv->watches);
   queue_empty(&solv->ruletojob);
@@ -3108,7 +3580,7 @@ solver_solve(Solver *solv, Queue *job)
     memset(solv->decisionmap, 0, pool->nsolvables * sizeof(Id));
   queue_empty(&solv->decisionq);
   queue_empty(&solv->decisionq_why);
-  solv->decisioncnt_update = solv->decisioncnt_keep = solv->decisioncnt_resolve = solv->decisioncnt_weak = solv->decisioncnt_orphan = 0;
+  queue_empty(&solv->decisionq_reason);
   queue_empty(&solv->learnt_why);
   queue_empty(&solv->learnt_pool);
   queue_empty(&solv->branches);
@@ -3121,9 +3593,12 @@ solver_solve(Solver *solv, Queue *job)
     {
       map_empty(&solv->recommendsmap);
       map_empty(&solv->suggestsmap);
+      queuep_free(&solv->recommendscplxq);
+      queuep_free(&solv->suggestscplxq);
       solv->recommends_index = 0;
     }
-  solv->multiversionupdaters = solv_free(solv->multiversionupdaters);
+  queuep_free(&solv->brokenorphanrules);
+  solv->specialupdaters = solv_free(solv->specialupdaters);
 
 
   /*
@@ -3143,20 +3618,21 @@ solver_solve(Solver *solv, Queue *job)
   now = solv_timems(0);
   /*
    * create rules for all package that could be involved with the solving
-   * so called: rpm rules
+   * so called: pkg rules
    *
    */
-  initialnrules = solv->rpmrules_end ? solv->rpmrules_end : 1;
+  initialnrules = solv->pkgrules_end ? solv->pkgrules_end : 1;
   if (initialnrules > 1)
     deduceq2addedmap(solv, &addedmap);
   if (solv->nrules != initialnrules)
     solver_shrinkrules(solv, initialnrules);
   solv->nrules = initialnrules;
-  solv->rpmrules_end = 0;
+  solv->pkgrules_end = 0;
 
   if (installed)
     {
       /* check for update/verify jobs as they need to be known early */
+      /* also setup the droporphaned map, we need it when creating update rules */
       for (i = 0; i < job->count; i += 2)
 	{
 	  how = job->elements[i];
@@ -3242,6 +3718,32 @@ solver_solve(Solver *solv, Queue *job)
 		    add_update_target(solv, p, how);
 		}
 	      break;
+	    case SOLVER_DROP_ORPHANED:
+	      if (select == SOLVER_SOLVABLE_ALL || (select == SOLVER_SOLVABLE_REPO && what == installed->repoid))
+		solv->droporphanedmap_all = 1;
+	      FOR_JOB_SELECT(p, pp, select, what)
+		{
+		  s = pool->solvables + p;
+		  if (s->repo != installed)
+		    continue;
+		  if (!solv->droporphanedmap.size)
+		    map_grow(&solv->droporphanedmap, installed->end - installed->start);
+		  MAPSET(&solv->droporphanedmap, p - installed->start);
+		}
+	      break;
+	    case SOLVER_ALLOWUNINSTALL:
+	      if (select == SOLVER_SOLVABLE_ALL || (select == SOLVER_SOLVABLE_REPO && installed && what == installed->repoid))
+		solv->allowuninstall_all = 1;
+	      FOR_JOB_SELECT(p, pp, select, what)
+		{
+		  s = pool->solvables + p;
+		  if (s->repo != installed)
+		    continue;
+		  if (!solv->allowuninstallmap.size)
+		    map_grow(&solv->allowuninstallmap, installed->end - installed->start);
+		  MAPSET(&solv->allowuninstallmap, p - installed->start);
+		}
+	      break;
 	    default:
 	      break;
 	    }
@@ -3252,12 +3754,12 @@ solver_solve(Solver *solv, Queue *job)
 
       oldnrules = solv->nrules;
       FOR_REPO_SOLVABLES(installed, p, s)
-	solver_addrpmrulesforsolvable(solv, s, &addedmap);
-      POOL_DEBUG(SOLV_DEBUG_STATS, "added %d rpm rules for installed solvables\n", solv->nrules - oldnrules);
+	solver_addpkgrulesforsolvable(solv, s, &addedmap);
+      POOL_DEBUG(SOLV_DEBUG_STATS, "added %d pkg rules for installed solvables\n", solv->nrules - oldnrules);
       oldnrules = solv->nrules;
       FOR_REPO_SOLVABLES(installed, p, s)
-	solver_addrpmrulesforupdaters(solv, s, &addedmap, 1);
-      POOL_DEBUG(SOLV_DEBUG_STATS, "added %d rpm rules for updaters of installed solvables\n", solv->nrules - oldnrules);
+	solver_addpkgrulesforupdaters(solv, s, &addedmap, 1);
+      POOL_DEBUG(SOLV_DEBUG_STATS, "added %d pkg rules for updaters of installed solvables\n", solv->nrules - oldnrules);
     }
 
   /*
@@ -3278,7 +3780,7 @@ solver_solve(Solver *solv, Queue *job)
 	  FOR_JOB_SELECT(p, pp, select, what)
 	    {
 	      MAPSET(&installcandidatemap, p);
-	      solver_addrpmrulesforsolvable(solv, pool->solvables + p, &addedmap);
+	      solver_addpkgrulesforsolvable(solv, pool->solvables + p, &addedmap);
 	    }
 	  break;
 	case SOLVER_DISTUPGRADE:
@@ -3289,31 +3791,33 @@ solver_solve(Solver *solv, Queue *job)
 	      if (how & SOLVER_FORCEBEST)
 		solv->bestupdatemap_all = 1;
 	    }
-	  if (!solv->dupmap_all)
-	    hasdupjob = 1;
+	  if ((how & SOLVER_TARGETED) != 0)
+	    needduprules = 1;
+	  if (!solv->dupmap_all || solv->allowuninstall || solv->allowuninstall_all || solv->allowuninstallmap.size || solv->keep_orphans)
+	    needduprules = 1;
 	  break;
 	default:
 	  break;
 	}
     }
-  POOL_DEBUG(SOLV_DEBUG_STATS, "added %d rpm rules for packages involved in a job\n", solv->nrules - oldnrules);
+  POOL_DEBUG(SOLV_DEBUG_STATS, "added %d pkg rules for packages involved in a job\n", solv->nrules - oldnrules);
 
 
   /*
    * add rules for suggests, enhances
    */
   oldnrules = solv->nrules;
-  solver_addrpmrulesforweak(solv, &addedmap);
-  POOL_DEBUG(SOLV_DEBUG_STATS, "added %d rpm rules because of weak dependencies\n", solv->nrules - oldnrules);
+  solver_addpkgrulesforweak(solv, &addedmap);
+  POOL_DEBUG(SOLV_DEBUG_STATS, "added %d pkg rules because of weak dependencies\n", solv->nrules - oldnrules);
 
 #ifdef ENABLE_LINKED_PKGS
   oldnrules = solv->nrules;
-  solver_addrpmrulesforlinked(solv, &addedmap);
-  POOL_DEBUG(SOLV_DEBUG_STATS, "added %d rpm rules because of linked packages\n", solv->nrules - oldnrules);
+  solver_addpkgrulesforlinked(solv, &addedmap);
+  POOL_DEBUG(SOLV_DEBUG_STATS, "added %d pkg rules because of linked packages\n", solv->nrules - oldnrules);
 #endif
 
   /*
-   * first pass done, we now have all the rpm rules we need.
+   * first pass done, we now have all the pkg rules we need.
    * unify existing rules before going over all job rules and
    * policy rules.
    * at this point the system is always solvable,
@@ -3334,18 +3838,18 @@ solver_solve(Solver *solv, Queue *job)
     }
 
   if (solv->nrules > initialnrules)
-    solver_unifyrules(solv);			/* remove duplicate rpm rules */
-  solv->rpmrules_end = solv->nrules;		/* mark end of rpm rules */
+    solver_unifyrules(solv);			/* remove duplicate pkg rules */
+  solv->pkgrules_end = solv->nrules;		/* mark end of pkg rules */
 
   if (solv->nrules > initialnrules)
     addedmap2deduceq(solv, &addedmap);		/* so that we can recreate the addedmap */
 
-  POOL_DEBUG(SOLV_DEBUG_STATS, "rpm rule memory used: %d K\n", solv->nrules * (int)sizeof(Rule) / 1024);
-  POOL_DEBUG(SOLV_DEBUG_STATS, "rpm rule creation took %d ms\n", solv_timems(now));
+  POOL_DEBUG(SOLV_DEBUG_STATS, "pkg rule memory used: %d K\n", solv->nrules * (int)sizeof(Rule) / 1024);
+  POOL_DEBUG(SOLV_DEBUG_STATS, "pkg rule creation took %d ms\n", solv_timems(now));
 
   /* create dup maps if needed. We need the maps early to create our
    * update rules */
-  if (hasdupjob)
+  if (needduprules)
     solver_createdupmaps(solv);
 
   /*
@@ -3368,10 +3872,10 @@ solver_solve(Solver *solv, Queue *job)
 	{
 	  if (s->repo != installed)
 	    {
-	      solver_addrule(solv, 0, 0);	/* create dummy rule */
+	      solver_addrule(solv, 0, 0, 0);	/* create dummy rule */
 	      continue;
 	    }
-	  solver_addupdaterule(solv, s, 1);    /* allow s to be updated */
+	  solver_addfeaturerule(solv, s);
 	}
       /* make sure we accounted for all rules */
       assert(solv->nrules - solv->featurerules == installed->end - installed->start);
@@ -3396,28 +3900,29 @@ solver_solve(Solver *solv, Queue *job)
 
 	  if (s->repo != installed)
 	    {
-	      solver_addrule(solv, 0, 0);	/* create dummy rule */
+	      solver_addrule(solv, 0, 0, 0);	/* create dummy rule */
 	      continue;
 	    }
-	  solver_addupdaterule(solv, s, 0);	/* allowall = 0: downgrades not allowed */
+	  solver_addupdaterule(solv, s);
 	  /*
 	   * check for and remove duplicate
 	   */
 	  r = solv->rules + solv->nrules - 1;           /* r: update rule */
 	  sr = r - (installed->end - installed->start); /* sr: feature rule */
-	  /* it's orphaned if there is no feature rule or the feature rule
-           * consists just of the installed package */
-	  if (!sr->p || (sr->p == i && !sr->d && !sr->w2))
-	    queue_push(&solv->orphaned, i);
           if (!r->p)
 	    {
-	      assert(solv->dupmap_all && !sr->p);
+	      if (sr->p)
+	        memset(sr, 0, sizeof(*sr));		/* no feature rules without update rules */
 	      continue;
 	    }
+	  /* it's also orphaned if the feature rule consists just of the installed package */
+	  if (!solv->dupmap_all && sr->p == i && !sr->d && !sr->w2)
+	    queue_push(&solv->orphaned, i);
+
 	  if (!solver_rulecmp(solv, r, sr))
 	    memset(sr, 0, sizeof(*sr));		/* delete unneeded feature rule */
-	  else
-	    solver_disablerule(solv, sr);	/* disable feature rule */
+	  else if (sr->p)
+	    solver_disablerule(solv, sr);	/* disable feature rule for now */
 	}
       /* consistency check: we added a rule for _every_ installed solvable */
       assert(solv->nrules - solv->updaterules == installed->end - installed->start);
@@ -3451,6 +3956,15 @@ solver_solve(Solver *solv, Queue *job)
 	      p = what;
 	      d = 0;
 	    }
+#ifdef ENABLE_COMPLEX_DEPS
+	  else if ((select == SOLVER_SOLVABLE_PROVIDES || select == SOLVER_SOLVABLE_NAME) && pool_is_complex_dep(pool, what))
+	    {
+	      if (add_complex_jobrules(solv, what, select == SOLVER_SOLVABLE_NAME ? CPLXDEPS_NAME : 0, i, weak))
+	        if (how & SOLVER_FORCEBEST)
+		  hasbestinstalljob = 1;
+	      break;
+	    }
+#endif
 	  else
 	    {
 	      queue_empty(&q);
@@ -3481,7 +3995,7 @@ solver_solve(Solver *solv, Queue *job)
 		  queue_pushunique(solv->installsuppdepq, rd->evr == 0 ? rd->name : what);
 		}
 	    }
-	  solver_addjobrule(solv, p, d, i, weak);
+	  solver_addjobrule(solv, p, 0, d, i, weak);
           if (how & SOLVER_FORCEBEST)
 	    hasbestinstalljob = 1;
 	  break;
@@ -3494,21 +4008,31 @@ solver_solve(Solver *solv, Queue *job)
 	  if (select == SOLVER_SOLVABLE_ALL)	/* hmmm ;) */
 	    {
 	      FOR_POOL_SOLVABLES(p)
-	        solver_addjobrule(solv, -p, 0, i, weak);
+	        solver_addjobrule(solv, -p, 0, 0, i, weak);
 	    }
 	  else if (select == SOLVER_SOLVABLE_REPO)
 	    {
-	      Repo *repo = pool_id2repo(pool, what);
-	      if (repo)
-		FOR_REPO_SOLVABLES(repo, p, s)
-		  solver_addjobrule(solv, -p, 0, i, weak);
+	      Repo *repo = pool_id2repo(pool, what);
+	      if (repo)
+		{
+		  FOR_REPO_SOLVABLES(repo, p, s)
+		    solver_addjobrule(solv, -p, 0, 0, i, weak);
+		}
+	    }
+#ifdef ENABLE_COMPLEX_DEPS
+	  else if ((select == SOLVER_SOLVABLE_PROVIDES || select == SOLVER_SOLVABLE_NAME) && pool_is_complex_dep(pool, what))
+	    {
+	      /* no special "erase a specific solvable" handling? */
+	      add_complex_jobrules(solv, what, select == SOLVER_SOLVABLE_NAME ? (CPLXDEPS_NAME | CPLXDEPS_TODNF | CPLXDEPS_INVERT) : (CPLXDEPS_TODNF | CPLXDEPS_INVERT), i, weak);
+	      break;
 	    }
+#endif
 	  FOR_JOB_SELECT(p, pp, select, what)
 	    {
 	      s = pool->solvables + p;
 	      if (installed && s->repo == installed)
 		name = !name ? s->name : -1;
-	      solver_addjobrule(solv, -p, 0, i, weak);
+	      solver_addjobrule(solv, -p, 0, 0, i, weak);
 	    }
 	  /* special case for "erase a specific solvable": we also
 	   * erase all other solvables with that name, so that they
@@ -3536,7 +4060,7 @@ solver_solve(Solver *solv, Queue *job)
 		    if (solv->rules[j].p == -p)
 		      break;
 		  if (j == k)
-		    solver_addjobrule(solv, -p, 0, i, weak);	/* remove by id */
+		    solver_addjobrule(solv, -p, 0, 0, i, weak);	/* remove by id */
 		}
 	    }
 	  break;
@@ -3562,47 +4086,52 @@ solver_solve(Solver *solv, Queue *job)
 	  if (select == SOLVER_SOLVABLE_ALL)
 	    {
 	      FOR_POOL_SOLVABLES(p)
-	        solver_addjobrule(solv, installed && pool->solvables[p].repo == installed ? p : -p, 0, i, weak);
+	        solver_addjobrule(solv, installed && pool->solvables[p].repo == installed ? p : -p, 0, 0, i, weak);
 	    }
           else if (select == SOLVER_SOLVABLE_REPO)
 	    {
 	      Repo *repo = pool_id2repo(pool, what);
 	      if (repo)
-	        FOR_REPO_SOLVABLES(repo, p, s)
-	          solver_addjobrule(solv, installed && pool->solvables[p].repo == installed ? p : -p, 0, i, weak);
+		{
+	          FOR_REPO_SOLVABLES(repo, p, s)
+	            solver_addjobrule(solv, installed && pool->solvables[p].repo == installed ? p : -p, 0, 0, i, weak);
+		}
 	    }
 	  FOR_JOB_SELECT(p, pp, select, what)
-	    solver_addjobrule(solv, installed && pool->solvables[p].repo == installed ? p : -p, 0, i, weak);
+	    solver_addjobrule(solv, installed && pool->solvables[p].repo == installed ? p : -p, 0, 0, i, weak);
 	  break;
 	case SOLVER_DISTUPGRADE:
 	  POOL_DEBUG(SOLV_DEBUG_JOB, "job: distupgrade %s\n", solver_select2str(pool, select, what));
 	  break;
 	case SOLVER_DROP_ORPHANED:
 	  POOL_DEBUG(SOLV_DEBUG_JOB, "job: drop orphaned %s\n", solver_select2str(pool, select, what));
-	  if (select == SOLVER_SOLVABLE_ALL || (select == SOLVER_SOLVABLE_REPO && installed && what == installed->repoid))
-	    solv->droporphanedmap_all = 1;
-	  FOR_JOB_SELECT(p, pp, select, what)
-	    {
-	      s = pool->solvables + p;
-	      if (!installed || s->repo != installed)
-		continue;
-	      if (!solv->droporphanedmap.size)
-		map_grow(&solv->droporphanedmap, installed->end - installed->start);
-	      MAPSET(&solv->droporphanedmap, p - installed->start);
-	    }
 	  break;
 	case SOLVER_USERINSTALLED:
 	  POOL_DEBUG(SOLV_DEBUG_JOB, "job: user installed %s\n", solver_select2str(pool, select, what));
 	  break;
+	case SOLVER_ALLOWUNINSTALL:
+	  POOL_DEBUG(SOLV_DEBUG_JOB, "job: allowuninstall %s\n", solver_select2str(pool, select, what));
+	  break;
+	case SOLVER_FAVOR:
+	case SOLVER_DISFAVOR:
+	  POOL_DEBUG(SOLV_DEBUG_JOB, "job: %s %s\n", (how & SOLVER_JOBMASK) == SOLVER_FAVOR ? "favor" : "disfavor", solver_select2str(pool, select, what));
+	  FOR_JOB_SELECT(p, pp, select, what)
+	    {
+	      int j;
+	      if (!solv->favorq)
+		{
+		  solv->favorq = solv_calloc(1, sizeof(Queue));
+		  queue_init(solv->favorq);
+		}
+	      j = solv->favorq->count + 1;
+	      queue_push2(solv->favorq, p, (how & SOLVER_JOBMASK) == SOLVER_FAVOR ? j : -j);
+	    }
+	  break;
 	default:
 	  POOL_DEBUG(SOLV_DEBUG_JOB, "job: unknown job\n");
 	  break;
 	}
 	
-	/*
-	 * debug
-	 */
-	
       IF_POOLDEBUG (SOLV_DEBUG_JOB)
 	{
 	  int j;
@@ -3618,6 +4147,10 @@ solver_solve(Solver *solv, Queue *job)
   assert(solv->ruletojob.count == solv->nrules - solv->jobrules);
   solv->jobrules_end = solv->nrules;
 
+  /* transform favorq into two maps */
+  if (solv->favorq)
+    setup_favormaps(solv);
+
   /* now create infarch and dup rules */
   if (!solv->noinfarchcheck)
     {
@@ -3635,19 +4168,29 @@ solver_solve(Solver *solv, Queue *job)
   else
     solv->infarchrules = solv->infarchrules_end = solv->nrules;
 
-  if (hasdupjob)
+  if (needduprules)
     solver_addduprules(solv, &addedmap);
   else
     solv->duprules = solv->duprules_end = solv->nrules;
 
+#ifdef ENABLE_LINKED_PKGS
+  if (solv->instbuddy && solv->updatemap.size)
+    extend_updatemap_to_buddies(solv);
+#endif
+
   if (solv->bestupdatemap_all || solv->bestupdatemap.size || hasbestinstalljob)
     solver_addbestrules(solv, hasbestinstalljob);
   else
     solv->bestrules = solv->bestrules_end = solv->nrules;
 
-  if (hasdupjob)
+  if (needduprules)
     solver_freedupmaps(solv);	/* no longer needed */
 
+  if (solv->do_yum_obsoletes)
+    solver_addyumobsrules(solv);
+  else
+    solv->yumobsrules = solv->yumobsrules_end = solv->nrules;
+
   if (1)
     solver_addchoicerules(solv);
   else
@@ -3668,15 +4211,18 @@ solver_solve(Solver *solv, Queue *job)
   map_free(&installcandidatemap);
   queue_free(&q);
 
-  POOL_DEBUG(SOLV_DEBUG_STATS, "%d rpm rules, 2 * %d update rules, %d job rules, %d infarch rules, %d dup rules, %d choice rules, %d best rules\n", solv->rpmrules_end - 1, solv->updaterules_end - solv->updaterules, solv->jobrules_end - solv->jobrules, solv->infarchrules_end - solv->infarchrules, solv->duprules_end - solv->duprules, solv->choicerules_end - solv->choicerules, solv->bestrules_end - solv->bestrules);
+  POOL_DEBUG(SOLV_DEBUG_STATS, "%d pkg rules, 2 * %d update rules, %d job rules, %d infarch rules, %d dup rules, %d choice rules, %d best rules\n", solv->pkgrules_end - 1, solv->updaterules_end - solv->updaterules, solv->jobrules_end - solv->jobrules, solv->infarchrules_end - solv->infarchrules, solv->duprules_end - solv->duprules, solv->choicerules_end - solv->choicerules, solv->bestrules_end - solv->bestrules);
   POOL_DEBUG(SOLV_DEBUG_STATS, "overall rule memory used: %d K\n", solv->nrules * (int)sizeof(Rule) / 1024);
 
   /* create weak map */
-  map_init(&solv->weakrulemap, solv->nrules);
-  for (i = 0; i < solv->weakruleq.count; i++)
+  if (solv->weakruleq.count)
     {
-      p = solv->weakruleq.elements[i];
-      MAPSET(&solv->weakrulemap, p);
+      map_grow(&solv->weakrulemap, solv->nrules);
+      for (i = 0; i < solv->weakruleq.count; i++)
+	{
+	  p = solv->weakruleq.elements[i];
+	  MAPSET(&solv->weakrulemap, p);
+	}
     }
 
   /* enable cleandepsmap creation if we have updatepkgs */
@@ -3704,9 +4250,9 @@ solver_solve(Solver *solv, Queue *job)
   /* disable update rules that conflict with our job */
   solver_disablepolicyrules(solv);
 
-  /* make initial decisions based on assertion rules */
-  makeruledecisions(solv);
-  POOL_DEBUG(SOLV_DEBUG_SOLVER, "problems so far: %d\n", solv->problems.count);
+  /* break orphans if requested */
+  if (solv->dupmap_all && solv->orphaned.count && solv->break_orphans)
+    solver_breakorphans(solv);
 
   /*
    * ********************************************
@@ -3809,20 +4355,12 @@ void solver_get_recommendations(Solver *solv, Queue *recommendationsq, Queue *su
       MAPZERO(&solv->recommendsmap);
 
       /* put all packages the solver already chose in the map */
-      if (solv->decisioncnt_weak)
-	{
-	  for (i = solv->decisioncnt_weak; i < solv->decisioncnt_orphan; i++)
-	    {
-	      Id why;
-	      why = solv->decisionq_why.elements[i];
-	      if (why)
-		continue;	/* forced by unit rule or dep resolving */
-	      p = solv->decisionq.elements[i];
-	      if (p < 0)
-		continue;
+      for (i = 1; i < solv->decisionq.count; i++)
+        if ((p = solv->decisionq.elements[i]) > 0 && solv->decisionq_why.elements[i] == 0)
+	  {
+	    if (solv->decisionq_reason.elements[solv->decisionmap[p]] == SOLVER_REASON_WEAKDEP)
 	      MAPSET(&solv->recommendsmap, p);
-	    }
-	}
+	  }
 
       for (i = 0; i < solv->decisionq.count; i++)
 	{
@@ -3835,6 +4373,13 @@ void solver_get_recommendations(Solver *solv, Queue *recommendationsq, Queue *su
 	      recp = s->repo->idarraydata + s->recommends;
 	      while ((rec = *recp++) != 0)
 		{
+#ifdef ENABLE_COMPLEX_DEPS
+		  if (pool_is_complex_dep(pool, rec))
+		    {
+		      do_complex_recommendations(solv, rec, &solv->recommendsmap, noselected);
+		      continue;
+		    }
+#endif
 		  FOR_PROVIDES(p, pp, rec)
 		    if (solv->decisionmap[p] > 0)
 		      break;
@@ -3900,6 +4445,13 @@ void solver_get_recommendations(Solver *solv, Queue *recommendationsq, Queue *su
 	      sugp = s->repo->idarraydata + s->suggests;
 	      while ((sug = *sugp++) != 0)
 		{
+#ifdef ENABLE_COMPLEX_DEPS
+		  if (pool_is_complex_dep(pool, sug))
+		    {
+		      do_complex_recommendations(solv, sug, &solv->suggestsmap, noselected);
+		      continue;
+		    }
+#endif
 		  FOR_PROVIDES(p, pp, sug)
 		    if (solv->decisionmap[p] > 0)
 		      break;
@@ -3996,24 +4548,6 @@ solver_create_state_maps(Solver *solv, Map *installedmap, Map *conflictsmap)
   pool_create_state_maps(solv->pool, &solv->decisionq, installedmap, conflictsmap);
 }
 
-void
-solver_trivial_installable(Solver *solv, Queue *pkgs, Queue *res)
-{
-  Pool *pool = solv->pool;
-  Map installedmap;
-  int i;
-  pool_create_state_maps(pool,  &solv->decisionq, &installedmap, 0);
-  pool_trivial_installable_multiversionmap(pool, &installedmap, pkgs, res, solv->multiversion.size ? &solv->multiversion : 0);
-  for (i = 0; i < res->count; i++)
-    if (res->elements[i] != -1)
-      {
-	Solvable *s = pool->solvables + pkgs->elements[i];
-	if (!strncmp("patch:", pool_id2str(pool, s->name), 6) && solvable_is_irrelevant_patch(s, &installedmap))
-	  res->elements[i] = -1;
-      }
-  map_free(&installedmap);
-}
-
 /*-------------------------------------------------------------------
  *
  * decision introspection
@@ -4094,31 +4628,8 @@ solver_describe_decision(Solver *solv, Id p, Id *infop)
     *infop = why > 0 ? why : -why;
   if (why > 0)
     return SOLVER_REASON_UNIT_RULE;
-  why = -why;
-  if (i < solv->decisioncnt_update)
-    {
-      if (i == 0)
-	return SOLVER_REASON_KEEP_INSTALLED;
-      return SOLVER_REASON_RESOLVE_JOB;
-    }
-  if (i < solv->decisioncnt_keep)
-    {
-      if (why == 0 && pp < 0)
-	return SOLVER_REASON_CLEANDEPS_ERASE;
-      return SOLVER_REASON_UPDATE_INSTALLED;
-    }
-  if (i < solv->decisioncnt_resolve)
-    {
-      if (why == 0 && pp < 0)
-	return SOLVER_REASON_CLEANDEPS_ERASE;
-      return SOLVER_REASON_KEEP_INSTALLED;
-    }
-  if (why > 0)
-    return SOLVER_REASON_RESOLVE;
-  /* weak or orphaned */
-  if (solv->decisionq.count < solv->decisioncnt_orphan)
-    return SOLVER_REASON_WEAKDEP;
-  return SOLVER_REASON_RESOLVE_ORPHAN;
+  i = solv->decisionmap[p] >= 0 ? solv->decisionmap[p] : -solv->decisionmap[p];
+  return solv->decisionq_reason.elements[i];
 }
 
 
@@ -4139,7 +4650,8 @@ solver_describe_weakdep_decision(Solver *solv, Id p, Queue *whyq)
       break;
   if (decisionno == solv->decisionq.count)
     return;	/* huh? */
-  if (decisionno < solv->decisioncnt_weak || decisionno >= solv->decisioncnt_orphan)
+  i = solv->decisionmap[p] >= 0 ? solv->decisionmap[p] : -solv->decisionmap[p];
+  if (solv->decisionq_reason.elements[i] != SOLVER_REASON_WEAKDEP)
     return;	/* huh? */
 
   /* 1) list all packages that recommend us */
@@ -4171,7 +4683,7 @@ solver_describe_weakdep_decision(Solver *solv, Id p, Queue *whyq)
 	  if (!p2 && found)
 	    {
 	      queue_push(whyq, SOLVER_REASON_RECOMMENDED);
-	      queue_push2(whyq, p2, rec);
+	      queue_push2(whyq, i, rec);
 	    }
 	}
     }
@@ -4240,8 +4752,10 @@ pool_job2solvables(Pool *pool, Queue *pkgs, Id how, Id what)
       Repo *repo = pool_id2repo(pool, what);
       Solvable *s;
       if (repo)
-	FOR_REPO_SOLVABLES(repo, p, s)
-	  queue_push(pkgs, p);
+	{
+	  FOR_REPO_SOLVABLES(repo, p, s)
+	    queue_push(pkgs, p);
+	}
     }
   else
     {
@@ -4297,6 +4811,399 @@ pool_isemptyupdatejob(Pool *pool, Id how, Id what)
   return 1;
 }
 
+static int
+get_userinstalled_cmp(const void *ap, const void *bp, void *dp)
+{
+  return *(Id *)ap - *(Id *)bp;
+}
+
+static int
+get_userinstalled_cmp_names(const void *ap, const void *bp, void *dp)
+{
+  Pool *pool = dp;
+  return strcmp(pool_id2str(pool, *(Id *)ap), pool_id2str(pool, *(Id *)bp));
+}
+
+static int
+get_userinstalled_cmp_namearch(const void *ap, const void *bp, void *dp)
+{
+  Pool *pool = dp;
+  int r;
+  r = strcmp(pool_id2str(pool, ((Id *)ap)[0]), pool_id2str(pool, ((Id *)bp)[0]));
+  if (r)
+    return r;
+  return strcmp(pool_id2str(pool, ((Id *)ap)[1]), pool_id2str(pool, ((Id *)bp)[1]));
+}
+
+static void
+get_userinstalled_sort_uniq(Pool *pool, Queue *q, int flags)
+{
+  Id lastp = -1, lasta = -1;
+  int i, j;
+  if (q->count < ((flags & GET_USERINSTALLED_NAMEARCH) ? 4 : 2))
+    return;
+  if ((flags & GET_USERINSTALLED_NAMEARCH) != 0)
+    solv_sort(q->elements, q->count / 2, 2 * sizeof(Id), get_userinstalled_cmp_namearch, pool);
+  else if ((flags & GET_USERINSTALLED_NAMES) != 0)
+    solv_sort(q->elements, q->count, sizeof(Id), get_userinstalled_cmp_names, pool);
+  else
+    solv_sort(q->elements, q->count, sizeof(Id), get_userinstalled_cmp, 0);
+  if ((flags & GET_USERINSTALLED_NAMEARCH) != 0)
+    {
+      for (i = j = 0; i < q->count; i += 2)
+	if (q->elements[i] != lastp || q->elements[i + 1] != lasta)
+	  {
+	    q->elements[j++] = lastp = q->elements[i];
+	    q->elements[j++] = lasta = q->elements[i + 1];
+	  }
+    }
+  else
+    {
+      for (i = j = 0; i < q->count; i++)
+	if (q->elements[i] != lastp)
+	  q->elements[j++] = lastp = q->elements[i];
+    }
+  queue_truncate(q, j);
+}
+
+static void
+namearch2solvables(Pool *pool, Queue *q, Queue *qout, int job)
+{
+  int i;
+  if (!pool->installed)
+    return;
+  for (i = 0; i < q->count; i += 2)
+    {
+      Id p, pp, name = q->elements[i], arch = q->elements[i + 1];
+      FOR_PROVIDES(p, pp, name)
+	{
+	  Solvable *s = pool->solvables + p;
+	  if (s->repo != pool->installed || s->name != name || (arch && s->arch != arch))
+	    continue;
+	  if (job)
+	    queue_push(qout, job);
+	  queue_push(qout, p);
+	}
+    }
+}
+
+void
+solver_get_userinstalled(Solver *solv, Queue *q, int flags)
+{
+  Pool *pool = solv->pool;
+  Id p, p2, pp;
+  Solvable *s;
+  Repo *installed = solv->installed;
+  int i, j;
+  Map userinstalled;
+  
+  map_init(&userinstalled, 0);
+  queue_empty(q);
+  /* first process jobs */
+  for (i = 0; i < solv->job.count; i += 2)
+    {
+      Id how = solv->job.elements[i];
+      Id what, select;
+      if (installed && (how & SOLVER_JOBMASK) == SOLVER_USERINSTALLED)
+	{
+	  if (!userinstalled.size)
+	    map_grow(&userinstalled, installed->end - installed->start);
+	  what = solv->job.elements[i + 1];
+	  select = how & SOLVER_SELECTMASK;
+	  if (select == SOLVER_SOLVABLE_ALL || (select == SOLVER_SOLVABLE_REPO && what == installed->repoid))
+	    {
+	      FOR_REPO_SOLVABLES(installed, p, s)
+	        MAPSET(&userinstalled, p - installed->start);
+	    }
+	  FOR_JOB_SELECT(p, pp, select, what)
+	    if (pool->solvables[p].repo == installed)
+	      MAPSET(&userinstalled, p - installed->start);
+	  continue;
+	}
+      if ((how & SOLVER_JOBMASK) != SOLVER_INSTALL)
+	continue;
+      if ((how & SOLVER_NOTBYUSER) != 0)
+	continue;
+      what = solv->job.elements[i + 1];
+      select = how & SOLVER_SELECTMASK;
+      FOR_JOB_SELECT(p, pp, select, what)
+        if (solv->decisionmap[p] > 0)
+	  {
+	    queue_push(q, p);
+#ifdef ENABLE_LINKED_PKGS
+	    if (has_package_link(pool, pool->solvables + p))
+	      {
+		int j;
+		Queue lq;
+		queue_init(&lq);
+		find_package_link(pool, pool->solvables + p, 0, &lq, 0, 0);
+		for (j = 0; j < lq.count; j++)
+		  if (solv->decisionmap[lq.elements[j]] > 0)
+		    queue_push(q, lq.elements[j]);
+	      }
+#endif
+	  }
+    }
+  /* now process updates of userinstalled packages */
+  if (installed && userinstalled.size)
+    {
+      for (i = 1; i < solv->decisionq.count; i++)
+	{
+	  p = solv->decisionq.elements[i];
+	  if (p <= 0)
+	    continue;
+	  s = pool->solvables + p;
+	  if (!s->repo)
+	    continue;
+	  if (s->repo == installed)
+	    {
+	      if (MAPTST(&userinstalled, p - installed->start))
+		queue_push(q, p);
+	      continue;
+	    }
+	  /* new package, check if we replace a userinstalled one */
+	  FOR_PROVIDES(p2, pp, s->name)
+	    {
+	      Solvable *ps = pool->solvables + p2;
+	      if (p2 == p || ps->repo != installed || !MAPTST(&userinstalled, p2 - installed->start))
+		continue;
+	      if (!pool->implicitobsoleteusesprovides && s->name != ps->name)
+		continue;
+	      if (pool->implicitobsoleteusescolors && !pool_colormatch(pool, s, ps))
+		continue;
+	      queue_push(q, p);
+	      break;
+	    }
+	  if (!p2 && s->repo != installed && s->obsoletes)
+	    {
+	      Id obs, *obsp = s->repo->idarraydata + s->obsoletes;
+	      while ((obs = *obsp++) != 0)
+		{
+		  FOR_PROVIDES(p2, pp, obs)
+		    {
+		      Solvable *ps = pool->solvables + p2;
+		      if (p2 == p || ps->repo != installed || !MAPTST(&userinstalled, p2 - installed->start))
+			continue;
+		      if (!pool->obsoleteusesprovides && !pool_match_nevr(pool, ps, obs))
+			continue;
+		      if (pool->obsoleteusescolors && !pool_colormatch(pool, s, ps)) 
+			continue;
+		      queue_push(q, p); 
+		      break;
+		    }
+		  if (p2)
+		    break;
+		}
+	    }
+	}
+    }
+  map_free(&userinstalled);
+
+  /* convert to desired output format */
+  if ((flags & GET_USERINSTALLED_NAMEARCH) != 0)
+    {
+      int qcount = q->count;
+      queue_insertn(q, 0, qcount, 0);
+      for (i = j = 0; i < qcount; i++)
+	{
+	  s = pool->solvables + q->elements[i + qcount];
+	  q->elements[j++] = s->name;
+	  q->elements[j++] = s->arch;
+	}
+    }
+  else if ((flags & GET_USERINSTALLED_NAMES) != 0)
+    {
+      for (i = 0; i < q->count; i++)
+	{
+	  s = pool->solvables + q->elements[i];
+	  q->elements[i] = s->name;
+	}
+    }
+  /* sort and unify */
+  get_userinstalled_sort_uniq(pool, q, flags);
+
+  /* invert if asked for */
+  if ((flags & GET_USERINSTALLED_INVERTED) != 0)
+    {
+      /* first generate queue with all installed packages */
+      Queue invq;
+      queue_init(&invq);
+      for (i = 1; i < solv->decisionq.count; i++)
+	{
+	  p = solv->decisionq.elements[i];
+	  if (p <= 0)
+	    continue;
+	  s = pool->solvables + p;
+	  if (!s->repo)
+	    continue;
+	  if ((flags & GET_USERINSTALLED_NAMEARCH) != 0)
+	    queue_push2(&invq, s->name, s->arch);
+	  else if ((flags & GET_USERINSTALLED_NAMES) != 0)
+	    queue_push(&invq, s->name);
+	  else
+	    queue_push(&invq, p);
+	}
+      /* push q on invq, just in case... */
+      queue_insertn(&invq, invq.count, q->count, q->elements);
+      get_userinstalled_sort_uniq(pool, &invq, flags);
+      /* subtract queues (easy as they are sorted and invq is a superset of q) */
+      if ((flags & GET_USERINSTALLED_NAMEARCH) != 0)
+	{
+	  if (q->count)
+	    {
+	      for (i = j = 0; i < invq.count; i += 2)
+		if (invq.elements[i] == q->elements[j] && invq.elements[i + 1] == q->elements[j + 1])
+		  {
+		    invq.elements[i] = invq.elements[i + 1] = 0;
+		    j += 2;
+		    if (j >= q->count)
+		      break;
+		  }
+	      queue_empty(q);
+	    }
+	  for (i = 0; i < invq.count; i += 2)
+	    if (invq.elements[i])
+	      queue_push2(q, invq.elements[i], invq.elements[i + 1]);
+	}
+      else
+	{
+	  if (q->count)
+	    {
+	      for (i = j = 0; i < invq.count; i++)
+		if (invq.elements[i] == q->elements[j])
+		  {
+		    invq.elements[i] = 0;
+		    if (++j >= q->count)
+		      break;
+		  }
+	      queue_empty(q);
+	    }
+	  for (i = 0; i < invq.count; i++)
+	    if (invq.elements[i])
+	      queue_push(q, invq.elements[i]);
+	}
+      queue_free(&invq);
+    }
+}
+
+void
+pool_add_userinstalled_jobs(Pool *pool, Queue *q, Queue *job, int flags)
+{
+  int i;
+
+  if ((flags & GET_USERINSTALLED_INVERTED) != 0)
+    {
+      Queue invq;
+      Id p, lastid;
+      Solvable *s;
+      int bad;
+      if (!pool->installed)
+	return;
+      queue_init(&invq);
+      if ((flags & GET_USERINSTALLED_NAMEARCH) != 0)
+	flags &= ~GET_USERINSTALLED_NAMES;	/* just in case */
+      FOR_REPO_SOLVABLES(pool->installed, p, s)
+	queue_push(&invq, flags & GET_USERINSTALLED_NAMES ? s->name : p);
+      if ((flags & GET_USERINSTALLED_NAMEARCH) != 0)
+	{
+	  /* for namearch we convert to packages */
+	  namearch2solvables(pool, q, &invq, 0);
+	  get_userinstalled_sort_uniq(pool, &invq, flags);
+	  namearch2solvables(pool, q, &invq, 0);
+	  flags = 0;
+	}
+      else
+	{
+	  queue_insertn(&invq, invq.count, q->count, q->elements);
+	  get_userinstalled_sort_uniq(pool, &invq, flags);
+	  /* now the fun part, add q again, sort, and remove all dups */
+	  queue_insertn(&invq, invq.count, q->count, q->elements);
+	}
+      if (invq.count > 1)
+	{
+	  if ((flags & GET_USERINSTALLED_NAMES) != 0)
+	    solv_sort(invq.elements, invq.count, sizeof(Id), get_userinstalled_cmp_names, pool);
+	  else
+	    solv_sort(invq.elements, invq.count, sizeof(Id), get_userinstalled_cmp, 0);
+	}
+      lastid = -1;
+      bad = 1;
+      for (i = 0; i < invq.count; i++)
+	{
+	  if (invq.elements[i] == lastid)
+	    {
+	      bad = 1;
+	      continue;
+	    }
+	  if (!bad)
+	    queue_push2(job, SOLVER_USERINSTALLED | (flags & GET_USERINSTALLED_NAMES ? SOLVER_SOLVABLE_NAME : SOLVER_SOLVABLE), lastid);
+	  bad = 0;
+	  lastid = invq.elements[i];
+	}
+      if (!bad)
+	queue_push2(job, SOLVER_USERINSTALLED | (flags & GET_USERINSTALLED_NAMES ? SOLVER_SOLVABLE_NAME : SOLVER_SOLVABLE), lastid);
+      queue_free(&invq);
+    }
+  else
+    {
+      if (flags & GET_USERINSTALLED_NAMEARCH)
+	namearch2solvables(pool, q, job, SOLVER_USERINSTALLED | SOLVER_SOLVABLE);
+      else
+	{
+	  for (i = 0; i < q->count; i++)
+	    queue_push2(job, SOLVER_USERINSTALLED | (flags & GET_USERINSTALLED_NAMES ? SOLVER_SOLVABLE_NAME : SOLVER_SOLVABLE), q->elements[i]);
+	}
+    }
+}
+
+int
+solver_alternatives_count(Solver *solv)
+{
+  Id *elements = solv->branches.elements;
+  int res, count;
+  for (res = 0, count = solv->branches.count; count; res++)
+    count -= elements[count - 2];
+  return res;
+}
+
+int
+solver_get_alternative(Solver *solv, Id alternative, Id *idp, Id *fromp, Id *chosenp, Queue *choices, int *levelp)
+{
+  int cnt = solver_alternatives_count(solv);
+  int count = solv->branches.count;
+  Id *elements = solv->branches.elements;
+  if (choices)
+    queue_empty(choices);
+  if (alternative <= 0 || alternative > cnt)
+    return 0;
+  elements += count;
+  for (; cnt > alternative; cnt--)
+    elements -= elements[-2];
+  if (levelp)
+    *levelp = elements[-1];
+  if (fromp)
+    *fromp = elements[-4];
+  if (idp)
+    *idp = elements[-3];
+  if (chosenp)
+    {
+      int i;
+      *chosenp = 0;
+      for (i = elements[-2]; i > 4; i--)
+	{
+	  Id p = -elements[-i];
+	  if (p > 0 && solv->decisionmap[p] == elements[-1] + 1)
+	    {
+	      *chosenp = p;
+	      break;
+	    }
+	}
+    }
+  if (choices)
+    queue_insertn(choices, 0, elements[-2] - 4, elements - elements[-2]);
+  return elements[-4] ? SOLVER_ALTERNATIVE_TYPE_RECOMMENDS : SOLVER_ALTERNATIVE_TYPE_RULE;
+}
+
 const char *
 solver_select2str(Pool *pool, Id select, Id what)
 {
@@ -4354,7 +5261,7 @@ pool_job2str(Pool *pool, Id how, Id what, Id flagmask)
       return "do nothing";
     case SOLVER_INSTALL:
       if (select == SOLVER_SOLVABLE && pool->installed && pool->solvables[what].repo == pool->installed)
-	strstart = "keep ", strend = "installed";
+	strstart = "keep ", strend = " installed";
       else if (select == SOLVER_SOLVABLE || select == SOLVER_SOLVABLE_NAME)
 	strstart = "install ";
       else if (select == SOLVER_SOLVABLE_PROVIDES)
@@ -4364,7 +5271,7 @@ pool_job2str(Pool *pool, Id how, Id what, Id flagmask)
       break;
     case SOLVER_ERASE:
       if (select == SOLVER_SOLVABLE && !(pool->installed && pool->solvables[what].repo == pool->installed))
-	strstart = "keep ", strend = "unstalled";
+	strstart = "keep ", strend = " uninstalled";
       else if (select == SOLVER_SOLVABLE_PROVIDES)
 	strstart = "deinstall all packages ";
       else
@@ -4380,7 +5287,7 @@ pool_job2str(Pool *pool, Id how, Id what, Id flagmask)
       strstart = "multi version ";
       break;
     case SOLVER_LOCK:
-      strstart = "update ";
+      strstart = "lock ";
       break;
     case SOLVER_DISTUPGRADE:
       strstart = "dist upgrade ";
@@ -4389,10 +5296,19 @@ pool_job2str(Pool *pool, Id how, Id what, Id flagmask)
       strstart = "verify ";
       break;
     case SOLVER_DROP_ORPHANED:
-      strstart = "deinstall ", strend = "if orphaned";
+      strstart = "deinstall ", strend = " if orphaned";
       break;
     case SOLVER_USERINSTALLED:
-      strstart = "regard ", strend = "as userinstalled";
+      strstart = "regard ", strend = " as userinstalled";
+      break;
+    case SOLVER_ALLOWUNINSTALL:
+      strstart = "allow deinstallation of ";
+      break;
+    case SOLVER_FAVOR:
+      strstart = "favor ";
+      break;
+    case SOLVER_DISFAVOR:
+      strstart = "disfavor ";
       break;
     default:
       strstart = "unknown job ";
@@ -4436,3 +5352,37 @@ pool_job2str(Pool *pool, Id how, Id what, Id flagmask)
   return pool_tmpappend(pool, s, "]", 0);
 }
 
+const char *
+solver_alternative2str(Solver *solv, int type, Id id, Id from)
+{
+  Pool *pool = solv->pool;
+  if (type == SOLVER_ALTERNATIVE_TYPE_RECOMMENDS)
+    {
+      const char *s = pool_dep2str(pool, id);
+      return pool_tmpappend(pool, s, ", recommended by ", pool_solvid2str(pool, from));
+    }
+  if (type == SOLVER_ALTERNATIVE_TYPE_RULE)
+    {
+      int rtype;
+      Id depfrom, depto, dep;
+      char buf[64];
+      if (solver_ruleclass(solv, id) == SOLVER_RULE_CHOICE)
+	id = solver_rule2pkgrule(solv, id);
+      rtype = solver_ruleinfo(solv, id, &depfrom, &depto, &dep);
+      if ((rtype & SOLVER_RULE_TYPEMASK) == SOLVER_RULE_JOB)
+	{
+	  if ((depto & SOLVER_SELECTMASK) == SOLVER_SOLVABLE_PROVIDES)
+	    return pool_dep2str(pool, dep);
+	  return solver_select2str(pool, depto & SOLVER_SELECTMASK, dep);
+	}
+      if (rtype == SOLVER_RULE_PKG_REQUIRES)
+	{
+	  const char *s = pool_dep2str(pool, dep);
+	  return pool_tmpappend(pool, s, ", required by ", pool_solvid2str(pool, depfrom));
+	}
+      sprintf(buf, "Rule #%d", id);
+      return pool_tmpjoin(pool, buf, 0, 0);
+    }
+  return "unknown alternative type";
+}
+