anchor.diff:  
                   if Seq.isEmpty !compatibleVersions then
                       let withPrereleases = Seq.filter (fun (v,_) -> currentRequirement.IncludingPrereleases().VersionRequirement.IsInRange(v,currentRequirement.Parent.IsRootRequirement() |> not)) versions
  -                    if relax then
  +                    if currentStep.Relax then
                           compatibleVersions := withPrereleases
                       else
                           if Seq.isEmpty withPrereleases |> not then
  
positive.code:             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)
                  if Seq.isEmpty compatibleVersions then
                      boostConflicts (currentStep.FilteredVersions,currentRequirement,conflictStatus) 
  
                  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 forceBreak = ref false
              
                      let versionsToExplore = ref compatibleVersions
  
                      let shouldTryHarder trial =
                          if !forceBreak then false else
                          if (!state).IsDone || Seq.isEmpty !versionsToExplore then false else
                          if trial < 1 then true else
                          conflicts |> Set.isEmpty
  
                      while shouldTryHarder !trial do
                          trial := !trial + 1
                          let versionToExplore = Seq.head !versionsToExplore
                          versionsToExplore := Seq.tail !versionsToExplore
                          match getExploredPackage(currentRequirement,versionToExplore) with
  
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
  