anchor.diff:  
       let loopTime = DateTime.UtcNow
   
  -    let rec fuseConflicts stackpack currentRequirement filteredVersions currentConflict priorConflictSteps =
  +    let fuseConflicts stackpack currentRequirement filteredVersions currentConflict priorConflictSteps =
           let currentConflict,stackpack = boostConflicts filteredVersions currentRequirement stackpack currentConflict
   
           match priorConflictSteps with
  
positive.code:                                                   Parent = Package(currentRequirement.Name,exploredPackage.Version,exploredPackage.Source) }
                                          GetPackageVersions = getVersionsF }}
  
                              step (Inner ((currentConflict,currentStep,currentRequirement), priorConflictSteps)) stackpack compatibleVersions flags
  
      let startingStep = {
          Relax              = false
  
negative.code:         FirstTrial  = true
          UnlistedSearch = false
      }
          
      let rec tryStep result =
          match result with
          | StepResult.State state -> state
          | StepResult.Stage (stage, stackpack, ver, flags) ->
              tryStep (step stage stackpack ver flags)
  
      let inline calculate () =
          let step = Step((currentConflict, startingStep, currentRequirement), [])
          tryStep (StepResult.Stage (step, stackpack, Seq.empty, flags))
  
      // Flag to ensure that we don't hide underlying exceptions in the finally block.
      let mutable exceptionThrown = false
      try
          let stepResult = calculate()
          let state =
              match stepResult with
              | { Status = ResolutionRaw.ConflictRaw _ } as conflict ->
                  if conflict.TryRelaxed then
                      stackpack.KnownConflicts.Clear()
                      stackpack.ConflictHistory.Clear()
                      let step = Step((conflict, { startingStep with Relax = true }, currentRequirement), [])
                      tryStep (StepResult.Stage (step, stackpack, Seq.empty, flags))
                  else
                      conflict
              | x -> x
  