anchor.diff:                  }
                   match getExploredPackage packageDetails getPackageDetailsF stackpack with
                   | stackpack, None ->
  -                    step (Inner(diveConflict, floatConflictOpt)) (currentStep,floatStepOpt) stackpack
  +                    step (Inner(currentConflict, priorConflictSteps)) currentStep stackpack
                               currentRequirement compatibleVersions  flags
   
                   | stackpack, Some exploredPackage ->
  
positive.code:         flags.FirstTrial || Set.isEmpty conflictState.Conflicts
          
  
      let rec step    (stage:Stage)           (currentStep:ResolverStep, floatStepOpt:ResolverStep option) 
                      (stackpack:StackPack)   (currentRequirement:PackageRequirement)  
                      compatibleVersions      (flags:StepFlags) =
  
          let fuseConflicts diveConflict floatConflictOpt =
              match diveConflict, floatConflictOpt with
              | diveConflict, Some floatConflict -> 
                  let continueConflict = 
                      { diveConflict with VersionsToExplore = floatConflict.VersionsToExplore }        
  
                  step (Inner(continueConflict,None)) (currentStep,floatStepOpt) stackpack 
                          currentRequirement compatibleVersions  flags 
              | diveConflict, None -> diveConflict
  
          match stage with            
          | Step  (diveConflict, floatConflictOpt)  -> 
              if Set.isEmpty currentStep.OpenRequirements then
                  let diveConflict =
                      { diveConflict with
                          Status = Resolution.Ok (cleanupNames currentStep.CurrentResolution) }
                
                  match diveConflict, floatConflictOpt, floatStepOpt with
                  | diveConflict, Some floatConflict, Some floatStep -> 
                      let continueConflict = {
                          diveConflict with
                              VersionsToExplore = floatConflict.VersionsToExplore
                      }        
                      match continueConflict.Status with
                      | Resolution.Conflict (_,conflicts,_,_)
  
negative.code:                             ,   forceBreak  = flags.ForceBreak
                              ,   firstTrial  = flags.FirstTrial
                              )
                      step (Outer (conflictState,priorConflictSteps)) currentStep stackpack
                               currentRequirement compatibleVersions  flags 
          | Outer (currentConflict, priorConflictSteps) ->
              if flags.Ready then 
                  fuseConflicts currentConflict priorConflictSteps
              else
                  let flags = StepFlags(flags.Ready,flags.UseUnlisted,flags.HasUnlisted,false,true)
  
                  let currentConflict = { currentConflict with VersionsToExplore = compatibleVersions }
  
                  step (Inner (currentConflict, priorConflictSteps)) currentStep stackpack
                              currentRequirement compatibleVersions  flags 
  
          | Inner (currentConflict, priorConflictSteps)->
              if not (keepLooping flags currentConflict) then
                  let flags =
                      if  not flags.UseUnlisted 
                       && flags.HasUnlisted 
                       && not currentConflict.Status.IsDone then
                          StepFlags(flags.Ready,true,flags.HasUnlisted,flags.ForceBreak,flags.FirstTrial)
                      else
                          StepFlags(true,flags.UseUnlisted,flags.HasUnlisted,flags.ForceBreak,flags.FirstTrial)
  
                  step (Outer(currentConflict, priorConflictSteps)) currentStep  stackpack 
                           currentRequirement compatibleVersions  flags 
              else
                  let flags = StepFlags(flags.Ready,flags.UseUnlisted,flags.HasUnlisted,flags.ForceBreak,false)
                  let (version,sources) & versionToExplore = Seq.head currentConflict.VersionsToExplore
  
                  let currentConflict = 
                      { currentConflict with VersionsToExplore = Seq.tail currentConflict.VersionsToExplore }
  
                  let packageDetails = {
                      GroupName          = groupName
  