anchor.diff:          flags.FirstTrial || Set.isEmpty conflictState.Conflicts
           
   
  -    let rec step    (stage:Stage)           (currentStep:ResolverStep, floatStepOpt:ResolverStep option) 
  +    let rec step    (stage:Stage)           (currentStep:ResolverStep) 
                       (stackpack:StackPack)   (currentRequirement:PackageRequirement)  
                       compatibleVersions      (flags:StepFlags) =
   
  -        let fuseConflicts diveConflict floatConflictOpt =
  -            match diveConflict, floatConflictOpt with
  -            | diveConflict, Some floatConflict -> 
  +        let fuseConflicts currentConflict priorConflictSteps =
  +            match currentConflict, priorConflictSteps with
  +            | currentConflict, (lastConflict,lastStep)::priorConflictSteps -> 
                   let continueConflict = 
  -                    { diveConflict with VersionsToExplore = floatConflict.VersionsToExplore }        
  -
  -                step (Inner(continueConflict,None)) (currentStep,floatStepOpt) stackpack 
  +                    { currentConflict with VersionsToExplore = lastConflict.VersionsToExplore }        
  +
  +                step (Inner(continueConflict,priorConflictSteps)) lastStep stackpack 
                           currentRequirement compatibleVersions  flags 
  -            | diveConflict, None -> diveConflict
  +            | currentConflict, [] -> currentConflict
   
           match stage with            
  -        | Step  (diveConflict, floatConflictOpt)  -> 
  +        | Step  (currentConflict, priorConflictSteps)  -> 
               if Set.isEmpty currentStep.OpenRequirements then
  -                let diveConflict =
  -                    { diveConflict with
  +                let currentConflict =
  +                    { currentConflict with
                           Status = Resolution.Ok (cleanupNames currentStep.CurrentResolution) }
                 
  -                match diveConflict, floatConflictOpt, floatStepOpt with
  -                | diveConflict, Some floatConflict, Some floatStep -> 
  +                match currentConflict, priorConflictSteps with
  +                | currentConflict, (lastConflict,lastStep)::priorConflictSteps -> 
                       let continueConflict = {
  -                        diveConflict with
  -                            VersionsToExplore = floatConflict.VersionsToExplore
  +                        currentConflict with
  +                            VersionsToExplore = lastConflict.VersionsToExplore
                       }        
                       match continueConflict.Status with
                       | Resolution.Conflict (_,conflicts,_,_)
  
positive.code:                         StepFlags(flags.Ready,flags.UseUnlisted,hasUnlisted,flags.ForceBreak,flags.FirstTrial)
                      if exploredPackage.Unlisted && not flags.UseUnlisted then
                          tracefn "     unlisted"
                          step (Inner (diveConflict, floatConflictOpt)) (currentStep,floatStepOpt) stackpack
                                  currentRequirement compatibleVersions  flags 
                      else
                          let nextStep =
                              {   Relax              = currentStep.Relax
                                  FilteredVersions   = Map.add currentRequirement.Name ([versionToExplore],diveConflict.GlobalOverride) currentStep.FilteredVersions
                                  CurrentResolution  = Map.add exploredPackage.Name exploredPackage currentStep.CurrentResolution
                                  ClosedRequirements = Set.add currentRequirement currentStep.ClosedRequirements
                                  OpenRequirements   = calcOpenRequirements(exploredPackage,globalFrameworkRestrictions,versionToExplore,currentRequirement,currentStep)
  
negative.code:         Resolution.Conflict(startingStep,Set.empty,currentRequirement,getVersionsF)
  
  
      let currentConflict : ConflictState = {
          Status               = (status : Resolution)
          LastConflictReported = DateTime.Now
          TryRelaxed           = false
  