anchor.diff:          let results =
             candidates
             |> AsyncSeq.choose (fun x -> match x with | Result.Ok v -> Some v | _ -> None)
  -          |> AsyncSeq.collect (fun nextState ->
  -            let node = Node (p, cs , nextState.Selections.[p])
  -            let visited = path |> List.contains node
  -            if visited <> true
  -            then
  -              step context resolver nextState (node :: path)
  -            else AsyncSeq.empty)
  +          |> AsyncSeq.filter(fun rv ->
  +            let node = Node (p, cs, rv)
  +            path |> List.contains node |> not)
  +          |> AsyncSeq.mapAsync (fun rv -> async {
  +            let m = rv.Manifest
  +            let privateState : SolverState = {
  +              Hints = state.Hints
  +              Root = m.PrivateDependencies
  +              Locations = state.Locations
  +              Selections = Map.empty
  +            }
  +
  +            let! privateSolution =
  +              (step context resolver privateState [Root m])
  +              |> AsyncSeq.choose(fun x ->
  +                match x with
  +                | Result.Ok x -> Some x
  +                | _ -> None)
  +              |> AsyncSeq.tryFirst
  +
  +            return
  +              match privateSolution with
  +              | Some ps ->
  +                let nextState = {
  +                   state with
  +                     Selections = state.Selections |> Map.add p (rv, ps)
  +                }
  +                let node = Node (p, cs, rv)
  +                Result.Ok <| step context resolver nextState (node :: path)
  +              | None -> Result.Error NoPrivateSolution
  +          })
   
           let solutions =
             results
  -          |> AsyncSeq.choose(fun x ->
  +          |> AsyncSeq.collect(fun x ->
               match x with
  -            | Result.Ok _ -> Some x
  -            | _ -> None)
  +            | Result.Ok next -> next
  +            | _ -> AsyncSeq.empty
  +          )
   
           let errors =
  -          candidates
  +          results
             |> AsyncSeq.choose(fun x ->
               match x with
               | Result.Error e -> Some e
  
positive.code:         yield!
            notVisited
            |> Seq.filter (fun d -> selections |> Map.containsKey d.Package)
            |> Seq.map (fun d -> (d.Package, selections.[d.Package]))
  
          let next =
            notVisited
            |> Seq.choose (fun d -> selections |> Map.tryFind d.Package)
            |> Seq.fold (fun deps m -> Set.union m.Manifest.Dependencies deps) Set.empty
  
          yield! loop nextVisited next
      }
  
negative.code:           yield! solutions
          | None ->
            for error in errors do
              System.Console.WriteLine error
              do! resolver.PostAndAsyncReply (fun ch -> MarkBadPath (path, (p, cs), error, ch))
              yield Result.Error error
          ()
  