anchor.diff:  
       let conflictState : ConflictState = {
           Status               = (status : Resolution)
  -        CurrentRequirement   = currentRequirement
           LastConflictReported = DateTime.Now
           TryRelaxed           = false
           GlobalOverride       = false
           Conflicts            = (Set.empty : Set<PackageRequirement>)
           VersionsToExplore    = (Seq.empty : seq<SemVerInfo * PackageSource list>)
  -        CompatibleVersions   = (Seq.empty : seq<SemVerInfo * PackageSource list>)
       }
  -
   
       let stackpack = {
           ExploredPackages     = Dictionary<PackageName*SemVerInfo,ResolvedPackage>()
           KnownConflicts       = (HashSet() : HashSet<Set<PackageRequirement> * ((SemVerInfo * PackageSource list) list * bool) option>)
           ConflictHistory      = (Dictionary() : Dictionary<PackageName, int>)
       }
  -
   
       let flags =
           StepFlags
  
positive.code:     // to the end of a package resolution
  
  
  
      let rec step ((Step conflictState | Inner conflictState | Outer conflictState) (* as stage :Stage*)  ) 
                   (currentStep:ResolverStep) (stackpack:StackPack)(flags:StepFlags) =
          
          if Set.isEmpty currentStep.OpenRequirements then
              { conflictState with
                 Status = Resolution.Ok (cleanupNames currentStep.CurrentResolution)
              }
          // ----------- TERMINATE --------------
          else
          verbosefn "  %d packages in resolution. %d requirements left" currentStep.CurrentResolution.Count currentStep.OpenRequirements.Count
  
          let currentRequirement = getCurrentRequirement packageFilter currentStep.OpenRequirements stackpack.ConflictHistory
          let conflicts = getConflicts currentStep currentRequirement stackpack.KnownConflicts
  
  
          let conflictState =
              if Set.isEmpty conflicts then
                  let getVersionsF = getVersionsF currentRequirement.Sources ResolverStrategy.Max groupName
                  { conflictState with
                      Status = Resolution.Conflict(currentStep,Set.empty,currentRequirement,getVersionsF)
                  }
              else
                  let getVersionsF = getVersionsF currentRequirement.Sources ResolverStrategy.Max groupName
                  { conflictState with
                      Status = Resolution.Conflict(currentStep,conflicts,Seq.head conflicts,getVersionsF)
                  }
  
  
          if not (Set.isEmpty conflicts) then
              conflictState
          // ----------- TERMINATE --------------
  
          else
          let compatibleVersions,globalOverride,tryRelaxed =
              getCompatibleVersions currentStep groupName currentRequirement getVersionsF
                      conflictState.GlobalOverride
                      globalStrategyForDirectDependencies
                      globalStrategyForTransitives
  
          let conflictState = {
              conflictState with
                  Conflicts         = conflicts
                  TryRelaxed        = tryRelaxed
                  GlobalOverride    = globalOverride
          }
  
          let conflictState, stackpack =
              if Seq.isEmpty compatibleVersions then
                  boostConflicts currentStep.FilteredVersions currentRequirement stackpack conflictState
              else
                  conflictState, stackpack
  
          let flags =
              StepFlags
                  (   ready       = false
                  ,   useUnlisted = false
                  ,   hasUnlisted = false
                  ,   forceBreak  = flags.ForceBreak
                  ,   firstTrial  = flags.FirstTrial
                  )
  
          let rec stepLoop (stage:Stage) (flags:StepFlags) =
              match stage with            
              | Step  conflictState
              | Outer conflictState ->
                  if flags.Ready then 
                      conflictState 
                  //------------EXIT STEPLOOP----------------    
                  else
                  let flags = StepFlags(flags.Ready,flags.UseUnlisted,flags.HasUnlisted,false,true)
  
                  let conflictState = {
                      conflictState with
                          VersionsToExplore = compatibleVersions
                  }
  
                  stepLoop (Inner conflictState) flags 
                  //------------STEPLOOP AGAIN----------------    
  
              | Inner conflictState ->
  
  //                let conflictState, flags =
  //                    match conflictState.Status with
  
negative.code: 
  
  type private Stage =
      | Step  of conflictState : ConflictState * diveConflict : ConflictState option
      | Outer of conflictState : ConflictState * diveConflict : ConflictState option
      | Inner of conflictState : ConflictState * diveConflict : ConflictState option
  
  
  /// Resolves all direct and transitive dependencies
  let Resolve (getVersionsF, getPackageDetailsF, groupName:GroupName, globalStrategyForDirectDependencies, globalStrategyForTransitives, globalFrameworkRestrictions, (rootDependencies:PackageRequirement Set), updateMode : UpdateMode) =
  