anchor.diff:              dependencies
               |> Set.filter (isIncluded restrictions)
   
  -    let isPackageCompatible allowTransisitivePrereleases (dependencies:DependencySet) (package:ResolvedPackage) : bool =
  +    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) ->
  -            if name = package.Name && not (requirement.IsInRange (package.Version, allowTransisitivePrereleases)) then
  +            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
  -            )
  +            else false)
           |> not // then we are not compatible
   
   
  
positive.code:                             |> 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)
  
                          if canTakePackage then
                              let nextStep =
  
negative.code: 
  type PackageResolution = Map<PackageName, ResolvedPackage>
  
  type ResolverStep = {
      Relax: bool
      FilteredVersions : Map<PackageName, ((SemVerInfo * PackageSource list) list * bool)>
      CurrentResolution : Map<PackageName,ResolvedPackage>;
      ClosedRequirements : Set<PackageRequirement>
      OpenRequirements : Set<PackageRequirement> }
  
  module DependencySetFilter =
      let isIncluded (restriction:FrameworkRestriction) (dependency:PackageName * VersionRequirement * FrameworkRestrictions) =
          let _,_,dependencyRestrictions = dependency
  