anchor.diff:                              |> Seq.map snd
                               // Ignore packages which have "OverrideAll", otherwise == will not work anymore.
                               |> Seq.filter (fun resolved -> lockedPackages.Contains resolved.Name |> not)
  -                            |> Seq.forall (DependencySetFilter.isPackageCompatible currentRequirement.TransitivePrereleases exploredPackage.Dependencies)
  +                            |> Seq.forall (DependencySetFilter.isPackageCompatible currentStep exploredPackage.Dependencies)
   
                           if canTakePackage then
                               let nextStep =
  
positive.code: 
  type PackageResolution = Map<PackageName, ResolvedPackage>
  
  module DependencySetFilter =
      let isIncluded (restriction:FrameworkRestriction) (dependency:PackageName * VersionRequirement * FrameworkRestrictions) =
          let _,_,dependencyRestrictions = dependency
  
negative.code:             dependencies
              |> Set.filter (isIncluded restrictions)
  
      let isPackageCompatible (currentStep:ResolverStep) (dependencies:DependencySet) (package:ResolvedPackage) : bool =
          dependencies
          // exists any non-matching stuff
          |> Seq.filter (fun (name, _, _) -> name = package.Name)
          |> Seq.exists (fun (name, requirement, restriction) ->
              let allowTransitivePreleases = 
                  (currentStep.ClosedRequirements |> Set.exists (fun r -> r.TransitivePrereleases && r.Name = name)) ||
                  (currentStep.OpenRequirements |> Set.exists (fun r -> r.TransitivePrereleases && r.Name = name))
  
              if not (requirement.IsInRange (package.Version, allowTransitivePreleases)) then
                  tracefn "   Incompatible dependency: %O %O conflicts with resolved version %O" name requirement package.Version
                  true
              else false)
          |> not // then we are not compatible
  
  
  