anchor.diff:      member __.FirstTrial  = firstTrial
   
   
  +
  +// While looping to evaluate a package resolution the 'dive conflict' is the one 
  +// being actively processed. When this conflict needs to pause its evaluation 
  +// to spawn a new child diveConflict it "floats" with it throughout the recursive
  +// evaluation. When the child diver has finished evaluating it will fuse with 
  +// the floater to make a new conflictState that will resume the dive.
   type private Stage =
  -    | Step  of conflictState : ConflictState * diveConflict : ConflictState option
  -    | Outer of conflictState : ConflictState * diveConflict : ConflictState option
  -    | Inner of conflictState : ConflictState * diveConflict : ConflictState option
  +    | Step  of diveConflict : ConflictState * floatConflict : ConflictState option
  +    | Outer of diveConflict : ConflictState * floatConflict : ConflictState option
  +    | Inner of diveConflict : ConflictState * floatConflict : ConflictState option
   
   
   /// Resolves all direct and transitive dependencies
  
positive.code:         OpenRequirements   = rootDependencies
      }
  
  
  
      let currentRequirement = getCurrentRequirement packageFilter startingStep.OpenRequirements (Dictionary())
  
      let status =
  
negative.code: }
  
  
  let private getExploredPackage (pkgConfig:PackageConfig) getPackageDetailsF (stackpack:StackPack) =
      let key = (pkgConfig.Dependency.Name, pkgConfig.Version)
  
      match stackpack.ExploredPackages.TryGetValue key with
      | true, package ->
          let package = updateRestrictions pkgConfig package
          stackpack.ExploredPackages.[key] <- package
          stackpack, Some package
      | false,_ ->
          match explorePackageConfig getPackageDetailsF pkgConfig with
          | Some explored ->
              stackpack.ExploredPackages.Add(key,explored)
              stackpack, Some explored
          | None ->
              stackpack, None
  
  
  
  