anchor.diff:  
         match conflicts with
         | Some (dep, _) ->
  -        System.Console.WriteLine (string (p, cs))
           yield Result.Error (Unresolvable dep.MinimumElement)
         | None ->
           for candidate in fetchCandidatesForConstraint sourceExplorer locations p c do
             match candidate with
             | Result.Error (Unresolvable d) ->
               unresolvableCores <- (unresolvableCores |> Map.add (Set [d]) (Unresolvable d))
  +
  +            System.Console.WriteLine "----------"
  +            for cores in unresolvableCores |> Map.keySet do
  +              cores |> Set |> System.Console.WriteLine
  +              System.Console.WriteLine "&&&&&"
  +            System.Console.WriteLine "----------"
  +
               yield Result.Error <| Unresolvable d
             | Result.Error (LimitReached d) ->
               if hadCandidate <> false
               then
                 underconstraintDeps <- (underconstraintDeps |> Set.add d)
  +              System.Console.WriteLine "----------"
  +              for cores in unresolvableCores |> Map.keySet do
  +                cores |> Set |> System.Console.WriteLine
  +                System.Console.WriteLine "&&&&&"
  +              System.Console.WriteLine "----------"
  +
               yield Result.Error <| LimitReached d
             | Result.Ok (_, (location, versions)) ->
               let! lock = sourceExplorer.LockLocation location
  
positive.code:           then
              yield candidate
            else
              System.Console.WriteLine "bar"
              yield Result.Error (Conflicts conflicts)
          ()
  
        ()
      }
  
      while true do
        let! req = inbox.Receive()
        match req with
        | GetCandidates (constraints, dep, locations, channel) ->
          trackLocal locations dep
          |> AsyncSeq.takeWhile (fun _ -> testIfHasBadCore constraints |> Seq.isEmpty)
          |> trackGlobal constraints
          |> channel.Reply
        | MarkBadPath (path, failedDep, errors, channel) ->
  
  
          let rec compute error =
  
            match error with
            | LimitReached _-> () // TODO
            | Unresolvable (p, bs) ->
              System.Console.WriteLine "unresolvable..."
  
              if failedDep <> (p, bs)
              then
                let groups =
                  world.[failedDep]
                  |> Set.map(fun xs ->
                    xs
                    |> Set.filter(fun (q, _) -> p = q )
                    |> Set.map(fun (_, cs) -> cs )
                    |> Set.unionMany)
  
                System.Console.WriteLine "xxx"
                for contribution in groups do
                  let core =
                    path
                    |> Seq.choose(fun x ->
                      match x with
                      | Root m -> Some m.Dependencies
                      | Node (q, rv) ->
                        if q <> fst failedDep && p <> q
                        then
                          Some rv.Manifest.Dependencies
                        else None)
                    |> Seq.map (fun deps ->
                      deps
                      |> Seq.map (fun x -> (x.Package, x.Constraint |> toDnf |> (fun c -> Set.difference c contribution)))
                      |> Seq.filter (fun (q, cs) -> cs.IsEmpty |> not)
                      |> Seq.filter (fun (q, cs) -> p = q && Set.isProperSubset cs bs) // should be an intersection?
                      |> Set)
                    |> Set.unionMany
                    |> Set.add failedDep
                  unresolvableCores <- unresolvableCores |> Map.add core (SearchStrategyError.Unresolvable (p, bs))
                else
                  unresolvableCores <- unresolvableCores |> Map.add (Set[(p, bs)]) (SearchStrategyError.Unresolvable (p, bs))
            | TransitiveConflict (core, next) ->
              System.Console.WriteLine (string (core, next))
              compute next
            | Conflicts cs ->
              for c in cs do compute c
  
          for error in errors do
            System.Console.WriteLine "errors"
            compute error
          channel.Reply ()
          System.Console.WriteLine "done"
  
  
    })
  
  
    let rec private step (context : TaskContext) (resolver : MailboxProcessor<ResolutionRequest>) (state : SolverState) (path: List<ResolutionPath>): AsyncSeq<SolverState> = asyncSeq {
      let sourceExplorer = context.SourceExplorer
      let log = namespacedLogger context.Console ("solver")
  
  
negative.code: 
      let result =
        resolutions
        |> AsyncSeq.choose (fun s ->
          match s with
          | Result.Ok s -> Some s
          | _ -> None
        )
        |> AsyncSeq.map (fun s ->
          Resolution.Ok <| {Resolutions = s.Selections |> Map.map(fun k v -> (v, Solution.empty))}
        )
  