anchor.diff:  }
   
   
  -let private getExploredPackage (pkgConfig:PackageConfig) getPackageDetailsF (exploredPackages:Dictionary<_,_>) =
  +let private getExploredPackage (pkgConfig:PackageConfig) getPackageDetailsF (stackpack:StackPack) =
       let key = (pkgConfig.Dependency.Name, pkgConfig.Version)
   
  -    match exploredPackages.TryGetValue key with
  +    match stackpack.ExploredPackages.TryGetValue key with
       | true, package ->
           let package = updateRestrictions pkgConfig package
  -        exploredPackages.[key] <- package
  -        Some package
  +        stackpack.ExploredPackages.[key] <- package
  +        stackpack, Some package
       | false,_ ->
           match explorePackageConfig getPackageDetailsF pkgConfig with
           | Some explored ->
  -            exploredPackages.Add(key,explored)
  -            Some explored
  +            stackpack.ExploredPackages.Add(key,explored)
  +            stackpack, Some explored
           | None ->
  -            None
  +            stackpack, None
   
   
   
  
positive.code:             ,   firstTrial  = true
              )
  
  
      match step (Step(conflictState,None)) startingStep stackpack flags  with
      | { Status = Resolution.Conflict _ } as conflict ->
          if conflict.TryRelaxed then
              stackpack.KnownConflicts.Clear()
              stackpack.ConflictHistory.Clear()
              (step (Step(conflict,None)) { startingStep with Relax = true } stackpack flags ).Status
          else
              conflict.Status
      | x -> x.Status
  
negative.code:         OpenRequirements   = rootDependencies
      }
  
      let currentRequirement = getCurrentRequirement packageFilter startingStep.OpenRequirements (Dictionary())
  
      let status =
  