anchor.diff:          { dependency with
               Name = n
               VersionRequirement = v
  -            Parent = Package(dependency.Name, versionToExplore, exploredPackage.Source)
  +            Parent = Package(dependency.Name, verCache.Version, exploredPackage.Source)
               Graph = Set.add dependency dependency.Graph
               TransitivePrereleases = dependency.TransitivePrereleases && exploredPackage.Version.PreRelease.IsSome
               Settings = { dependency.Settings with FrameworkRestrictions = newRestrictions } })
  
positive.code:             self.Ready self.UseUnlisted self.HasUnlisted self.ForceBreak self.FirstTrial self.UnlistedSearch
  
  type private Stage =
      | Step  of currentConflict : (ConflictState * ResolverStep * PackageRequirement) * priorConflictSteps : (ConflictState * ResolverStep * PackageRequirement *  seq<SemVerInfo * PackageSource list> * StepFlags) list
      | Outer of currentConflict : (ConflictState * ResolverStep * PackageRequirement) * priorConflictSteps : (ConflictState * ResolverStep * PackageRequirement *  seq<SemVerInfo * PackageSource list> * StepFlags) list
      | Inner of currentConflict : (ConflictState * ResolverStep * PackageRequirement) * priorConflictSteps : (ConflictState * ResolverStep * PackageRequirement *  seq<SemVerInfo * PackageSource list> * StepFlags) list
  
  type WorkPriority =
      | BackgroundWork = 10
  
negative.code:             |> Set.filter (fun r -> currentRequirement.Name = r.Name)
  
          // we didn't select a version yet so all versions are possible
          let isInRange mapF (cache:VersionCache) =
              allRequirementsOfCurrentPackage
              |> Set.forall (fun r -> (mapF r).VersionRequirement.IsInRange cache.Version)
  
          let getSingleVersion v =
              let sources = 
                  match currentRequirement.Parent with
                  | PackageRequirementSource.Package(_,_,parentSource) ->
                      parentSource :: currentRequirement.Sources |> List.distinct
                  | _ ->
                      currentRequirement.Sources |> List.sortBy (fun x -> not x.IsLocalFeed, String.containsIgnoreCase "nuget.org" x.Url |> not)
              Seq.singleton (VersionCache.ofParams v sources true)
  
          let availableVersions =
              let resolverStrategy = getResolverStrategy globalStrategyForDirectDependencies globalStrategyForTransitives allRequirementsOfCurrentPackage currentRequirement
              let allVersions =
                  getVersionsF resolverStrategy (GetPackageVersionsParameters.ofParams currentRequirement.Sources groupName currentRequirement.Name)
                  |> Seq.map (fun (v, sources) -> VersionCache.ofParams v sources false)
              match currentRequirement.VersionRequirement.Range with
              | Specific v
              | OverrideAll v ->
                  let results =
                      allVersions
                      |> Seq.filter (fun cache -> cache.Version = v)
                      |> Seq.toList
                  match results with
                  | [] -> getSingleVersion v 
                  | _ -> List.toSeq results
              | _ -> allVersions
                  
          let compatibleVersions = Seq.filter (isInRange id) availableVersions |> Seq.cache
  