anchor.diff:              )
   
   
  -    match step (Step conflictState) startingStep stackpack flags  with
  +    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) { startingStep with Relax = true } stackpack flags ).Status
  +            (step (Step(conflict,None)) { startingStep with Relax = true } stackpack flags ).Status
           else
               conflict.Status
       | x -> x.Status
  
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:         |> Seq.map (fun x -> x.Name,x.Settings)
          |> dict
  
      if Set.isEmpty rootDependencies then Resolution.Ok Map.empty 
      //      ----------- TERMINATE --------------
      else
  
  
  
  
  
  