anchor.diff:  
   
   type PackageResolution = Map<PackageName, ResolvedPackage>
  +/// Caches information retrieved by GetVersions until it is required by GetDetails
  +type VersionCache =
  +  { Version : SemVerInfo; Sources : PackageSource list; AssumedVersion : bool }
  +    static member ofParams version sources isAssumed =
  +        { Version = version; Sources = sources; AssumedVersion = isAssumed }
   
   type ResolverStep = {
       Relax: bool
  -    FilteredVersions : Map<PackageName, ((SemVerInfo * PackageSource list) list * bool)>
  +    FilteredVersions : Map<PackageName, (VersionCache list * bool)>
       CurrentResolution : Map<PackageName,ResolvedPackage>;
       ClosedRequirements : Set<PackageRequirement>
       OpenRequirements : Set<PackageRequirement> }
  
positive.code:             |> Set.filter (fun r -> currentRequirement.Name = r.Name)
  
          // we didn't select a version yet so all versions are possible
          let isInRange mapF (ver,_) =
              allRequirementsOfCurrentPackage
              |> Set.forall (fun r -> (mapF r).VersionRequirement.IsInRange ver)
  
          //let getSingleVersion v =
          //    match currentRequirement.Parent with
          //    | PackageRequirementSource.Package(_,_,parentSource) ->
          //        let sources = parentSource :: currentRequirement.Sources |> List.distinct
          //        Seq.singleton (v,sources)
          //    | _ ->
          //        let sources : PackageSource list = currentRequirement.Sources |> List.sortBy (fun x -> not x.IsLocalFeed, String.containsIgnoreCase "nuget.org" x.Url |> not)
          //        Seq.singleton (v,sources)
  
          let availableVersions =
              let resolverStrategy = getResolverStrategy globalStrategyForDirectDependencies globalStrategyForTransitives allRequirementsOfCurrentPackage currentRequirement
              let allVersions = getVersionsF resolverStrategy (GetPackageVersionsParameters.ofParams currentRequirement.Sources groupName currentRequirement.Name)
              match currentRequirement.VersionRequirement.Range with
              | Specific v
              | OverrideAll v -> 
                  allVersions
                  |> Seq.filter (fun (v1, _) -> v1 = v)
                  //getSingleVersion v
              | _ -> allVersions
                  
          let compatibleVersions = Seq.filter (isInRange id) availableVersions |> Seq.cache
  
negative.code:         
          
  let private boostConflicts
                      (filteredVersions:Map<PackageName, (VersionCache list * bool)>)
                      (currentRequirement:PackageRequirement)
                      (stackpack:StackPack)
                      (conflictState:ConflictState) =
  