anchor.diff:          flags.FirstTrial || Set.isEmpty conflictState.Conflicts
           
   
  -    let rec step    (stage:Stage)           (currentStep:ResolverStep) 
  -                    (stackpack:StackPack)   (currentRequirement:PackageRequirement)  
  -                    compatibleVersions      (flags:StepFlags) =
  +    let rec step (stage:Stage) (stackpack:StackPack) compatibleVersions (flags:StepFlags) =
   
           let fuseConflicts currentConflict priorConflictSteps =
               match currentConflict, priorConflictSteps with
  -            | currentConflict, (lastConflict,lastStep)::priorConflictSteps -> 
  +            | currentConflict, (lastConflict,lastStep,lastRequirement)::priorConflictSteps -> 
                   let continueConflict = 
                       { currentConflict with VersionsToExplore = lastConflict.VersionsToExplore }        
   
  -                step (Inner(continueConflict,priorConflictSteps)) lastStep stackpack 
  -                        currentRequirement compatibleVersions  flags 
  +                step (Inner((continueConflict,lastStep,lastRequirement),priorConflictSteps))  stackpack compatibleVersions  flags 
               | currentConflict, [] -> currentConflict
   
           match stage with            
  -        | Step  (currentConflict, priorConflictSteps)  -> 
  +        | Step((currentConflict,currentStep,_currentRequirement), priorConflictSteps)  -> 
               if Set.isEmpty currentStep.OpenRequirements then
                   let currentConflict =
                       { currentConflict with
                           Status = Resolution.Ok (cleanupNames currentStep.CurrentResolution) }
                 
                   match currentConflict, priorConflictSteps with
  -                | currentConflict, (lastConflict,lastStep)::priorConflictSteps -> 
  +                | currentConflict, (lastConflict,lastStep,lastRequirement)::priorConflictSteps -> 
                       let continueConflict = {
                           currentConflict with
                               VersionsToExplore = lastConflict.VersionsToExplore
  
positive.code:                             (Set.isEmpty conflicts |> not)
                              && currentStep.CurrentResolution.Count > 1
                              && not (conflicts |> Set.exists (fun r ->
                                  r = currentRequirement
                                  || r.Graph |> List.contains currentRequirement)) ->
                          let flags = 
                              StepFlags(flags.Ready,flags.UseUnlisted,flags.HasUnlisted,true,flags.FirstTrial)
                         
                          step (Inner(continueConflict,priorConflictSteps)) lastStep stackpack
                              currentRequirement compatibleVersions  flags 
                      | _ ->
                          step (Inner(continueConflict,priorConflictSteps)) lastStep stackpack 
                              currentRequirement compatibleVersions  flags 
                  
                  | currentConflict, [] -> currentConflict
  
  
negative.code:     member __.FirstTrial  = firstTrial
  
  
  type private Stage =
      | Step  of currentConflict : (ConflictState * ResolverStep * PackageRequirement) * priorConflictSteps : (ConflictState * ResolverStep * PackageRequirement) list
      | Outer of currentConflict : (ConflictState * ResolverStep * PackageRequirement) * priorConflictSteps : (ConflictState * ResolverStep * PackageRequirement) list
      | Inner of currentConflict : (ConflictState * ResolverStep * PackageRequirement) * priorConflictSteps : (ConflictState * ResolverStep * PackageRequirement) list
  
  
  /// Resolves all direct and transitive dependencies
  