anchor.diff:                                                  Environment.NewLine currentRequirement Environment.NewLine nextStep.OpenRequirements
                               step (Step((currentConflict,nextStep,currentRequirement), (currentConflict,currentStep,currentRequirement,compatibleVersions,flags)::priorConflictSteps)) stackpack currentConflict.VersionsToExplore flags
                           else
  +                            let getVersionsF =
  +                                getVersionsBlock currentRequirement.Sources ResolverStrategy.Max groupName
  +                            let conflictingPackage,(_,vr,_) = conflictingResolvedPackages |> Seq.head
  +                            let currentConflict =    
  +                                { currentConflict with
  +                                    Status = ResolutionRaw.ConflictRaw {
  +                                        ResolveStep = currentStep
  +                                        RequirementSet = Set.empty
  +                                        Requirement = 
  +                                            { currentRequirement with 
  +                                                  Name = conflictingPackage.Name
  +                                                  VersionRequirement = vr
  +                                                  Parent = Package(currentRequirement.Name,exploredPackage.Version,exploredPackage.Source)  }
  +                                        GetPackageVersions = getVersionsF }}
  +
                               step (Inner ((currentConflict,currentStep,currentRequirement), priorConflictSteps)) stackpack compatibleVersions flags
   
       let startingStep = {
  
positive.code:             Dependencies =
                  package.Dependencies
                  |> Set.map (fun (name, v, d) -> model.[name].Name, v, d) })
  
  
  
  
  type ConflictInfo =
  
negative.code:             dependencies
              |> Set.filter (isIncluded restrictions)
  
      let findFirstIncompatibility (currentStep:ResolverStep) (dependencies:DependencySet) (package:ResolvedPackage) =
          dependencies
          // exists any non-matching stuff
          |> Seq.filter (fun (name, _, _) -> name = package.Name)
          |> Seq.filter (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))
  
              not (requirement.IsInRange (package.Version, allowTransitivePreleases)))
          |> Seq.tryHead
  
  let cleanupNames (model : PackageResolution) : PackageResolution =
      model
  