anchor.diff:              if conflicts |> Set.isEmpty |> not then 
                   Resolution.Conflict(currentStep,conflicts,Seq.head conflicts,getVersionsF) 
               else
  -                let availableVersions,compatibleVersions,globalOverride = getCompatibleVersions(currentStep.Relax,currentStep.FilteredVersions,currentStep.OpenRequirements,currentRequirement)
  -
  -                let conflictStatus = Resolution.Conflict(currentStep,Set.empty,currentRequirement,getVersionsF)
  +                let availableVersions,compatibleVersions,globalOverride = getCompatibleVersions(currentStep,currentRequirement)
  +
  +                let state = ref (Resolution.Conflict(currentStep,Set.empty,currentRequirement,getVersionsF))
                   if Seq.isEmpty compatibleVersions then
  -                    boostConflicts (currentStep.FilteredVersions,currentRequirement,conflictStatus) 
  +                    boostConflicts (currentStep.FilteredVersions,currentRequirement,!state) 
   
                   let ready = ref false
  -                let state = ref conflictStatus
                   let useUnlisted = ref false
                   let hasUnlisted = ref false
   
                   while not !ready do
  -                    let trial = ref 0
  +                    let firstTrial = ref true
                       let forceBreak = ref false
               
                       let versionsToExplore = ref compatibleVersions
   
  -                    let shouldTryHarder trial =
  +                    let shouldTryHarder () =
                           if !forceBreak then false else
                           if (!state).IsDone || Seq.isEmpty !versionsToExplore then false else
  -                        if trial < 1 then true else
  +                        if !firstTrial then true else
                           conflicts |> Set.isEmpty
   
  -                    while shouldTryHarder !trial do
  -                        trial := !trial + 1
  +                    while shouldTryHarder() do
  +                        firstTrial := false
                           let versionToExplore = Seq.head !versionsToExplore
                           versionsToExplore := Seq.tail !versionsToExplore
                           match getExploredPackage(currentRequirement,versionToExplore) with
  
positive.code: 
                  if Seq.isEmpty !compatibleVersions then
                      let withPrereleases = Seq.filter (fun (v,_) -> currentRequirement.IncludingPrereleases().VersionRequirement.IsInRange(v,currentRequirement.Parent.IsRootRequirement() |> not)) versions
                      if relax then
                          compatibleVersions := withPrereleases
                      else
                          if Seq.isEmpty withPrereleases |> not then
  
negative.code:             with
              | _ -> None
  
      let getCompatibleVersions(currentStep:ResolverStep,currentRequirement:PackageRequirement) =
          verbosefn "  Trying to resolve %O" currentRequirement
  
          let availableVersions = ref Seq.empty
          let compatibleVersions = ref Seq.empty
          let globalOverride = ref false
         
          match Map.tryFind currentRequirement.Name currentStep.FilteredVersions with
          | None ->
              let allRequirementsOfCurrentPackage =
                  currentStep.OpenRequirements
                  |> Set.filter (fun r -> currentRequirement.Name = r.Name)
  
              // we didn't select a version yet so all versions are possible
  