anchor.diff:                              ,   forceBreak  = flags.ForceBreak
                               ,   firstTrial  = flags.FirstTrial
                               )
  -                    step (Outer (conflictState,floatConflictOpt)) (currentStep,floatStepOpt) stackpack
  +                    step (Outer (conflictState,priorConflictSteps)) currentStep stackpack
                                currentRequirement compatibleVersions  flags 
  -        | Outer (diveConflict, floatConflictOpt) ->
  +        | Outer (currentConflict, priorConflictSteps) ->
               if flags.Ready then 
  -                fuseConflicts diveConflict floatConflictOpt 
  +                fuseConflicts currentConflict priorConflictSteps
               else
                   let flags = StepFlags(flags.Ready,flags.UseUnlisted,flags.HasUnlisted,false,true)
   
  -                let diveConflict = { diveConflict with VersionsToExplore = compatibleVersions }
  -
  -                step (Inner (diveConflict, floatConflictOpt)) (currentStep,floatStepOpt) stackpack
  +                let currentConflict = { currentConflict with VersionsToExplore = compatibleVersions }
  +
  +                step (Inner (currentConflict, priorConflictSteps)) currentStep stackpack
                               currentRequirement compatibleVersions  flags 
   
  -        | Inner (diveConflict, floatConflictOpt)->
  -            if not (keepLooping flags diveConflict) then
  +        | Inner (currentConflict, priorConflictSteps)->
  +            if not (keepLooping flags currentConflict) then
                   let flags =
                       if  not flags.UseUnlisted 
                        && flags.HasUnlisted 
  -                     && not diveConflict.Status.IsDone then
  +                     && 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(diveConflict, floatConflictOpt)) (currentStep,floatStepOpt)  stackpack 
  +                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 diveConflict.VersionsToExplore
  -
  -                let diveConflict = 
  -                    { diveConflict with VersionsToExplore = Seq.tail diveConflict.VersionsToExplore }
  +                let (version,sources) & versionToExplore = Seq.head currentConflict.VersionsToExplore
  +
  +                let currentConflict = 
  +                    { currentConflict with VersionsToExplore = Seq.tail currentConflict.VersionsToExplore }
   
                   let packageDetails = {
                       GroupName          = groupName
  
positive.code:             ,   firstTrial  = true
              )
  
      match step (Step(diveConflict,None)) (startingStep,None) stackpack currentRequirement  Seq.empty flags  with
      | { Status = Resolution.Conflict _ } as conflict ->
          if conflict.TryRelaxed then
              stackpack.KnownConflicts.Clear()
              stackpack.ConflictHistory.Clear()
              (step   (Step(conflict,None)) 
                      ({startingStep with Relax=true},None) 
                      stackpack currentRequirement Seq.empty flags).Status
          else
              conflict.Status
  
negative.code: 
  // While looping to evaluate a package resolution the 'dive conflict' is the one 
  // being actively processed. When this conflict needs to pause its evaluation 
  // to spawn a new child currentConflict it "floats" with it throughout the recursive
  // evaluation. When the child diver has finished evaluating it will fuse with 
  // the floater to make a new conflictState that will resume the dive.
  type private Stage =
      | Step  of currentConflict : ConflictState * priorConflictSteps : (ConflictState * ResolverStep) list
      | Outer of currentConflict : ConflictState * priorConflictSteps : (ConflictState * ResolverStep) list
      | Inner of currentConflict : ConflictState * priorConflictSteps : (ConflictState * ResolverStep) list
  
  
  /// Resolves all direct and transitive dependencies
  