anchor.diff:              ,   firstTrial  = true
               )
   
  -    match step (Step(diveConflict,None)) (startingStep,None) stackpack currentRequirement  Seq.empty flags  with
  +    match step (Step(currentConflict,[])) (startingStep) 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) 
  +            (step   (Step(conflict,[])) 
  +                    {startingStep with Relax=true} 
                       stackpack currentRequirement Seq.empty flags).Status
           else
               conflict.Status
  
positive.code:                         let flags = 
                              StepFlags(flags.Ready,flags.UseUnlisted,flags.HasUnlisted,true,flags.FirstTrial)
                         
                          step (Inner(continueConflict,None)) (floatStep,floatStepOpt) stackpack
                              currentRequirement compatibleVersions  flags 
                      | _ ->
                          step (Inner(continueConflict,None)) (floatStep,floatStepOpt) stackpack 
                              currentRequirement compatibleVersions  flags 
                  
                  | diveConflict, _, _ -> diveConflict
  
              else
                  verbosefn "  %d packages in resolution. %d requirements left" 
  
negative.code:         flags.FirstTrial || Set.isEmpty conflictState.Conflicts
          
  
      let rec step    (stage:Stage)           (currentStep:ResolverStep) 
                      (stackpack:StackPack)   (currentRequirement:PackageRequirement)  
                      compatibleVersions      (flags:StepFlags) =
  
          let fuseConflicts currentConflict priorConflictSteps =
              match currentConflict, priorConflictSteps with
              | currentConflict, (lastConflict,lastStep)::priorConflictSteps -> 
                  let continueConflict = 
                      { currentConflict with VersionsToExplore = lastConflict.VersionsToExplore }        
  
                  step (Inner(continueConflict,priorConflictSteps)) lastStep stackpack 
                          currentRequirement compatibleVersions  flags 
              | currentConflict, [] -> currentConflict
  
          match stage with            
          | Step  (currentConflict, priorConflictSteps)  -> 
              if Set.isEmpty currentStep.OpenRequirements then
                  let currentConflict =
                      { currentConflict with
                          Status = Resolution.Ok (cleanupNames currentStep.CurrentResolution) }
                
                  match currentConflict, priorConflictSteps with
                  | currentConflict, (lastConflict,lastStep)::priorConflictSteps -> 
                      let continueConflict = {
                          currentConflict with
                              VersionsToExplore = lastConflict.VersionsToExplore
                      }        
                      match continueConflict.Status with
                      | Resolution.Conflict (_,conflicts,_,_)
  