anchor.diff:      yield! Set.difference
         (dependencies |> Map.keys |> Set.ofSeq)
         (solution.Resolutions |> Map.keys  |> Set.ofSeq)
  -
  -    let maybeSatisfied =
  -      Set.intersect
  -        (dependencies |> Map.keys |> Set.ofSeq)
  -        (solution.Resolutions |> Map.keys  |> Set.ofSeq)
  -
  -    yield!
  -      maybeSatisfied
  -      |> Set.toSeq
  -      |> Seq.map (fun package ->
  -        (package,
  -         Constraint.satisfies
  -           (Constraint.All (dependencies.[package] |> Set.toList ))
  -           (fst solution.Resolutions.[package]).Versions ))
  -      |> Seq.filter(snd >> not)
  -      |> Seq.map fst
  -  }
  +  }
  +
  +  // let underSpecified (solution : Solution) (dependencies : Constraint) = seq {
  +  //   let maybeSatisfied =
  +  //     Set.intersect
  +  //       (dependencies |> Map.keys |> Set.ofSeq)
  +  //       (solution.Resolutions |> Map.keys  |> Set.ofSeq)
  +
  +  //   yield!
  +  //     maybeSatisfied
  +  //     |> Set.toSeq
  +  //     |> Seq.map (fun package ->
  +  //       (package,
  +  //        Constraint.satisfies
  +  //          (Constraint.All (dependencies.[package] |> Set.toList ))
  +  //          (fst solution.Resolutions.[package]).Versions ))
  +  //     |> Seq.filter(snd >> not)
  +  //     |> Seq.map fst
  +  // }
   
     let private lockToHints (lock : Lock) =
       lock.Packages
  
positive.code:       | Resolution.Failure f ->
          log("Backtracking due to failure " + f.ToString() |> text, LoggingLevel.Debug)
          false
        | _ -> true
      )
  
  
negative.code:     }
    let fetchCandidatesForConstraint sourceExplorer locations package constraints = asyncSeq {
      let candidatesToExplore = SourceExplorer.fetchLocationsForConstraint sourceExplorer locations package constraints
      let mutable hasCandidates = false
  
      for x in candidatesToExplore do
        yield!
          match x with
          | Candidate (a,b) -> asyncSeq {
              let! lock = sourceExplorer.LockLocation a
              do! sourceExplorer.FetchManifest (lock, b) |> Async.Ignore
              yield Result.Ok (package, (a, b))
            }
          | Unsatisfiable u -> asyncSeq {
            yield
              Result.Error (SearchStrategyError.NotSatisfiable {
              Package = package;
              Constraint = u
              Msg = "Constraint not satisfiable"
            })
          }
  
        hasCandidates <- true
  
      if hasCandidates = false then
        yield Result.Error (SearchStrategyError.NotSatisfiable {
            Package = package;
            Constraint = constraints;
            Msg = "No Version has a valid manifest"
        })
    }
  
    let constraintsOf (ds: Set<Dependency>) =
  