anchor.diff:                          if exploredPackage.Unlisted && not useUnlisted then (allUnlisted,state) else                
                           let newFilteredVersion = Map.add dependency.Name ([versionToExplore],globalOverride) filteredVersions
                           
  -                        let newOpen = calcOpenRequirements(exploredPackage,versionToExplore,dependency,closed,stillOpen,rest)
  +                        let newOpen = calcOpenRequirements(exploredPackage,versionToExplore,dependency,closed,stillOpen)
                               
                           (exploredPackage.Unlisted && allUnlisted),improveModel (newFilteredVersion,exploredPackage::packages,Set.add dependency closed,newOpen)
                       | ResolvedPackages.Ok _ -> allUnlisted,state)
  
positive.code: 
      let rec improveModel (filteredVersions:Map<PackageName, (SemVerInfo list * bool)>,packages:ResolvedPackage list,closed:Set<PackageRequirement>,stillOpen:Set<PackageRequirement>) =
          if Set.isEmpty stillOpen then
              let isOk =
                  filteredVersions
                  |> Map.forall (fun _ v ->
  
negative.code:                             List.filter (fun v -> dependency.VersionRequirement.IsInRange(v,dependency.Parent.IsRootRequirement() |> not)) versions
                          versions,filtered,false
  
              if compatibleVersions = [] && dependency.Parent.IsRootRequirement() then    
                  let versionText = String.Join(Environment.NewLine + "     - ",List.sort allVersions)
                  failwithf "Could not find compatible versions for top level dependency:%s     %A%s   Available versions:%s     - %s%s   Try to relax the dependency or allow prereleases." 
                      Environment.NewLine (dependency.ToString()) Environment.NewLine Environment.NewLine versionText Environment.NewLine
                  
              let sorted =                
                  if dependency.Parent.IsRootRequirement() then
                      List.sort compatibleVersions |> List.rev
                  else
                      match dependency.ResolverStrategy with
                      | ResolverStrategy.Max -> List.sort compatibleVersions |> List.rev
                      | ResolverStrategy.Min -> List.sort compatibleVersions
  