anchor.diff:          None
   
   
  +type StackPack = {
  +    ExploredPackages     : Dictionary<PackageName*SemVerInfo,ResolvedPackage>
  +    KnownConflicts       : HashSet<Set<PackageRequirement> * ((SemVerInfo * PackageSource list) list * bool) option>
  +    ConflictHistory      : Dictionary<PackageName, int>
  +}
  +
   
   let private getExploredPackage (pkgConfig:PackageConfig) getPackageDetailsF (exploredPackages:Dictionary<_,_>) =
       let key = (pkgConfig.Dependency.Name, pkgConfig.Version)
  
positive.code:                     if nextStep.OpenRequirements = currentStep.OpenRequirements then
                          failwithf "The resolver confused itself. The new open requirements are the same as the old ones. This will result in an endless loop.%sCurrent Requirement: %A%sRequirements: %A" Environment.NewLine currentRequirement Environment.NewLine nextStep.OpenRequirements
  
                      let versionsToExplore = conflictState.VersionsToExplore
  
                      let conflictState = {
                          step nextStep flags with
                              VersionsToExplore = versionsToExplore
                      }
  
                      match conflictState.Status with
                      | Resolution.Conflict(_,conflicts,_,_)
                          when
                              (Set.isEmpty conflicts |> not)
                              && nextStep.CurrentResolution.Count > 1
                              && not (conflicts |> Set.exists (fun r ->
                                  r = currentRequirement
                                  || r.Graph |> List.contains currentRequirement)) ->
                          let flags = StepFlags(flags.Ready,flags.UseUnlisted,flags.HasUnlisted,true,flags.FirstTrial)
                          stepLoop flags (Inner (conflictState))
                      | _ ->
                          stepLoop flags (Inner (conflictState))
  
          stepLoop flags (Outer conflictState)
          // ----------- TERMINATE --------------
  
      match step startingStep flags  with
      | { Status = Resolution.Conflict _ } as conflict ->
          if conflict.TryRelaxed then
              knownConflicts.Clear()
              conflictHistory.Clear()
              (step { startingStep with Relax = true } flags ).Status
          else
              conflict.Status
      | x -> x.Status
  
negative.code: open Paket.Logging
  open System.Collections.Generic
  open System
  open System.Diagnostics
  open Paket.PackageSources
  
  type DependencySet = Set<PackageName * VersionRequirement * FrameworkRestrictions>
  