anchor.diff:          |> Seq.map (fun x -> x.Name,x.Settings)
           |> dict
   
  -    if Set.isEmpty rootDependencies then Resolution.Ok Map.empty else
  -
  -    let startingStep = {
  -        Relax = false
  -        FilteredVersions   = Map.empty
  -        CurrentResolution  = Map.empty
  -        ClosedRequirements = Set.empty
  -        OpenRequirements   = rootDependencies
  -    }
  +    if Set.isEmpty rootDependencies then Resolution.Ok Map.empty 
  +    //      ----------- TERMINATE --------------
  +    else
  +
  +
   
   
   
  
positive.code: 
      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
  
negative.code:     // to the end of a package resolution
  
  
      let rec stepLoop    (stage:Stage) (currentStep:ResolverStep) (stackpack:StackPack) 
                          (currentRequirement:PackageRequirement)  compatibleVersions (flags:StepFlags) =
          match stage with            
          | Step  (conflictState, diver)
          | Outer (conflictState, diver) ->
              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, diver))(currentStep:ResolverStep)  (stackpack:StackPack) 
                          (currentRequirement:PackageRequirement) compatibleVersions  flags 
              //------------STEPLOOP AGAIN----------------    
  
          | Inner (conflictState,diver )->
  
  //                let conflictState, flags =
  //                    match conflictState.Status with
  