anchor.diff:                                  GetPackageVersions = getVersionsF }}
   
                   if not (Seq.isEmpty conflicts) then
  -                    fuseConflicts currentRequirement currentStep.FilteredVersions currentConflict priorConflictSteps conflicts
  +                    fuseConflicts currentRequirement currentStep.FilteredVersions currentConflict priorConflictSteps
                   else
                       let getCurrentVersionBlock = fun strategy args -> getVersionsBlock strategy args currentStep
                       let compatibleVersions,globalOverride,tryRelaxed =
  
positive.code:                 conflictState.AddError(raise(TimeoutException(message)))
              else conflictState
      
          let fuseConflicts currentRequirement filteredVersions currentConflict priorConflictSteps conflicts =
              let currentConflict,stackpack = boostConflicts filteredVersions currentRequirement stackpack currentConflict
              let matchingStep =
                  let currentNames =
                      conflicts
                      |> Seq.map (fun c ->
                          c.Graph
                          |> Set.map (fun (pr:PackageRequirement) -> pr.Name) 
                          |> Set.add c.Name)
                      |> Set.unionMany
  
                  priorConflictSteps
                  |> List.tryExtractOne (fun (_,_,lastRequirement:PackageRequirement,_,_) ->
                      currentNames |> Set.contains lastRequirement.Name)
  
              match matchingStep with
              | None, [] -> currentConflict
              | (Some head), priorConflictSteps ->
                  let (lastConflict, lastStep, lastRequirement, lastCompatibleVersions, lastFlags) = head
                  let continueConflict = 
                      { currentConflict with VersionsToExplore = lastConflict.VersionsToExplore }
                  step (Inner((continueConflict,lastStep,lastRequirement), priorConflictSteps)) stackpack lastCompatibleVersions lastFlags
              // could not find a specific package - go back one step
              | None, head :: priorConflictSteps ->
                  let (lastConflict, lastStep, lastRequirement, lastCompatibleVersions, lastFlags) = head
                  let continueConflict = 
                      { currentConflict with VersionsToExplore = lastConflict.VersionsToExplore }        
                  step (Inner((continueConflict,lastStep,lastRequirement), priorConflictSteps)) stackpack lastCompatibleVersions lastFlags
                          
          match stage with            
          | Step((conflictState,currentStep,_currentRequirement), priorConflictSteps)  ->
  
negative.code:         | Outer ((conflictState,currentStep,currentRequirement), priorConflictSteps) ->
              let currentConflict = resolverTimeout conflictState currentStep
              if flags.Ready then
                  fuseConflicts currentRequirement currentStep.FilteredVersions currentConflict priorConflictSteps
              else
                  let flags = {
                    flags with
  