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: 
                  match getExploredPackage packageConfig getPackageDetailsBlock stackpack with
                  | stackpack, Result.Error err ->
                      step (Inner((currentConflict.AddError err.SourceException,currentStep,currentRequirement), priorConflictSteps)) stackpack compatibleVersions  flags
  
                  | stackpack, Result.Ok(alreadyExplored,exploredPackage) ->
                      let hasUnlisted = exploredPackage.Unlisted || flags.HasUnlisted
  
negative.code:                     else
                          // It might be that this version is already not possible because of our current set.
                          // Example: We took A with version 1.0.0 (in our current resolution), but this version depends on A > 1.0.0
                          let conflictingResolvedPackages =
                              currentStep.CurrentResolution
                              |> Map.toSeq
                              |> Seq.map snd
                              // Ignore packages which have "OverrideAll", otherwise == will not work anymore.
                              |> Seq.filter (fun resolved -> lockedPackages.Contains resolved.Name |> not)
                              |> Seq.choose (fun r -> 
                                  DependencySetFilter.findFirstIncompatibility currentStep exploredPackage.Dependencies r
                                  |> Option.map (fun incompat -> r,incompat))
  
                          let canTakePackage = conflictingResolvedPackages |> Seq.isEmpty
  
                          if canTakePackage then
                              let nextStep =
  