anchor.diff:                                      loadedLibs.Add(key,v)
                                       v
   
  -                            Some (assembly, BindingRedirects.getPublicKeyToken assembly)
  +                            Some (assembly, BindingRedirects.getPublicKeyToken assembly, assembly.GetReferencedAssemblies())
                           with exn -> None)
  -                    |> Seq.sortBy(fun (assembly,_) -> assembly.GetName().Version)
  +                    |> Seq.sortBy(fun (assembly,_,_) -> assembly.GetName().Version)
                       |> Seq.toList
                       |> List.rev
                       |> function | head :: _ -> Some head | _ -> None)
                   |> Seq.cache
   
               assemblies
  -            |> Seq.choose (fun (assembly,token) -> token |> Option.map (fun token -> (assembly,token)))
  -            |> Seq.filter (fun (assembly,_) -> 
  -                assemblies
  -                |> Seq.collect (fun (a,_) -> a.GetReferencedAssemblies())
  +            |> Seq.choose (fun (assembly,token,refs) -> token |> Option.map (fun token -> (assembly,token,refs)))
  +            |> Seq.filter (fun (assembly,_,refs) -> 
  +            assemblies
  +            |> Seq.collect (fun (_,_,refs) -> refs)
                   |> Seq.filter (fun a -> assembly.GetName().Name = a.Name)
                   |> Seq.exists (fun a -> assembly.GetName().Version > a.Version))
  -            |> Seq.map(fun (assembly, token) ->
  +            |> Seq.map(fun (assembly, token,_) ->
                   { BindingRedirect.AssemblyName = assembly.GetName().Name
                     Version = assembly.GetName().Version.ToString()
                     PublicKeyToken = token
  
positive.code: open Paket.PackagesConfigFile
  open Paket.Requirements
  open System.Collections.Generic
  
  let updatePackagesConfigFile (model: Map<GroupName*PackageName,SemVerInfo*InstallSettings>) packagesConfigFileName =
      let packagesInConfigFile = PackagesConfigFile.Read packagesConfigFileName
  
negative.code: 
  /// Applies binding redirects for all strong-named references to all app. and web.config files.
  let private applyBindingRedirects (loadedLibs:Dictionary<_,_>) createNewBindingFiles root groupName findDependencies (extractedPackages:seq<_*InstallModel>) =
      let dependencyGraph = ConcurrentDictionary<_,Set<_>>()
      let projects = ConcurrentDictionary<_,ProjectFile option>();
  
      let rec dependencies (projectFile : ProjectFile) =
          match ProjectFile.FindReferencesFile (FileInfo projectFile.FileName) with
          | Some fileName -> 
              let referenceFile = ReferencesFile.FromFile fileName
              projectFile.GetInterProjectDependencies()
              |> Seq.map (fun r -> projects.GetOrAdd(r.Path, ProjectFile.TryLoad))
              |> Seq.choose id
              |> Seq.collect (fun p -> dependencyGraph.GetOrAdd(p, dependencies))
              |> Seq.append (
                  referenceFile.Groups
                  |> Seq.filter (fun g -> g.Key = groupName)
                  |> Seq.collect (fun g -> g.Value.NugetPackages |> List.map (fun p -> (groupName,p.Name)))
                  |> Seq.collect findDependencies)
              |> Set.ofSeq
          | None -> Set.empty
  
      let bindingRedirects (projectFile : ProjectFile) =
          match ProjectFile.FindReferencesFile (FileInfo projectFile.FileName) with
          | Some fileName -> 
              let dependencies = dependencyGraph.GetOrAdd(projectFile, dependencies)
  
              let assemblies =
                  extractedPackages
                  |> Seq.map snd
                  |> Seq.filter (fun model -> dependencies |> Set.contains model.PackageName)
                  |> Seq.map (fun model -> model.GetLibReferences(projectFile.GetTargetProfile()))
                  |> Seq.concat
                  |> Seq.groupBy (fun p -> FileInfo(p).Name)
  