anchor.diff:          |> not)
       |> Set.union rest
   
  +
   type Resolved = {
       ResolvedPackages : Resolution
       ResolvedSourceFiles : ModuleResolver.ResolvedSourceFile list }
  +
  +let getResolverStrategy globalStrategyForTransitives (allRequirementsOfCurrentPackage:Set<PackageRequirement>) (currentRequirement:PackageRequirement) =
  +    if currentRequirement.Parent.IsRootRequirement() && Set.count allRequirementsOfCurrentPackage = 1 then
  +        ResolverStrategy.Max
  +    else
  +        let combined =
  +            (allRequirementsOfCurrentPackage
  +                |> List.ofSeq
  +                |> List.filter (fun x -> x.Depth > 0)
  +                |> List.sortBy (fun x -> x.Depth, x.ResolverStrategy <> globalStrategyForTransitives, x.ResolverStrategy <> Some ResolverStrategy.Max)
  +                |> List.map (fun x -> x.ResolverStrategy)
  +                |> List.fold (++) None)
  +                ++ globalStrategyForTransitives
  +                    
  +        defaultArg combined ResolverStrategy.Max
   
   type UpdateMode =
       | UpdateGroup of GroupName
  
positive.code:        
          match Map.tryFind currentRequirement.Name filteredVersions with
          | None ->
              let currentRequirements =
                  openRequirements
                  |> Set.filter (fun r -> currentRequirement.Name = r.Name)
  
              let resolverStrategy =
                  let combined =
                      (currentRequirements
                      |> List.ofSeq
                      |> List.filter (fun x -> x.Depth > 0)
                      |> List.sortBy (fun x -> x.Depth, x.ResolverStrategy <> strategy, x.ResolverStrategy <> Some ResolverStrategy.Max)
                      |> List.map (fun x -> x.ResolverStrategy)
                      |> List.fold (++) None)
                      ++ strategy
                      |> function | Some s -> s | None -> ResolverStrategy.Max
  
                  match updateMode with
                  | Install
                  | UpdateAll
                  | UpdateGroup _ ->
                      match currentRequirement.Parent.IsRootRequirement(), Set.count currentRequirements with
                      | true, 1 -> ResolverStrategy.Max
                      | _ -> combined
                  | UpdateFiltered (g, f) ->
                      match groupName = g && f.Match currentRequirement.Name with
                      | true -> ResolverStrategy.Max
                      | false -> combined
  
              // we didn't select a version yet so all versions are possible
              let isInRange mapF (ver,_) =
                  currentRequirements
                  |> Seq.forall (fun r -> (mapF r).VersionRequirement.IsInRange ver)
  
              let getSingleVersion v =
  
negative.code:     | UpdateAll
  
  /// Resolves all direct and transitive dependencies
  let Resolve(groupName:GroupName, sources, getVersionsF, getPackageDetailsF, globalStrategyForTransitives, globalFrameworkRestrictions, (rootDependencies:PackageRequirement Set), updateMode : UpdateMode) =
      tracefn "Resolving packages for group %O:" groupName
      let lastConflictReported = ref DateTime.Now
  
  