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:         FirstTrial  = true
          UnlistedSearch = false
      }
  
      let inline calculate () = step (Step((currentConflict,startingStep,currentRequirement),[])) stackpack Seq.empty flags
  
      // Flag to ensure that we don't hide underlying exceptions in the finally block.
      let mutable exceptionThrown = false
      try
  #if DEBUG && !DOTNETCORE
          let mutable results = None
          let mutable error = None
          // Increase stack size, because we have no tail-call-elimination
          let thread = new System.Threading.Thread((fun () ->
              try
                  results <- Some (calculate())
              with e ->
                  // Prevent the application from crashing
                  error <- Some (System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture e)
              ), 1024 * 1024 * 100)
          thread.Name <- sprintf "Paket Resolver Thread (Debug) - %O" (System.Guid.NewGuid())
          thread.Start()
          thread.Join()
          match error with
          | Some e -> e.Throw()
          | _ -> ()
          let stepResult =
              match results with
              | Some s -> s
              | None -> failwithf "Expected to get results from the resolver thread :/."
  #else
          let stepResult = calculate()
  #endif
          let state =
              match stepResult with
              | { Status = ResolutionRaw.ConflictRaw _ } as conflict ->
                  if conflict.TryRelaxed then
                      stackpack.KnownConflicts.Clear()
                      stackpack.ConflictHistory.Clear()
                      (step (Step((conflict
                                  ,{startingStep with Relax=true}
                                  ,currentRequirement),[]))
                            stackpack Seq.empty flags)
                  else
                      conflict
              | x -> x
  
negative.code:                         HasUnlisted = false
                          UnlistedSearch = false
                      }
                      StepResult.Stage ((Outer ((conflictState,currentStep,currentRequirement),priorConflictSteps)), stackpack, compatibleVersions, flags)
          | Outer ((conflictState,currentStep,currentRequirement), priorConflictSteps) ->
              let currentConflict = resolverTimeout conflictState currentStep
              if flags.Ready then
  