anchor.diff:  
   /// 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 -> ProjectFile.TryLoad r.Path)
  +            |> Seq.map (fun r -> projects.GetOrAdd(r.Path, ProjectFile.TryLoad))
               |> Seq.choose id
  -            |> Seq.collect dependencies
  +            |> 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)
  -            |> Seq.cache
  -        | None -> Seq.empty
  +            |> Set.ofSeq
  +        | None -> Set.empty
   
       let bindingRedirects (projectFile : ProjectFile) =
           match ProjectFile.FindReferencesFile (FileInfo projectFile.FileName) with
           | Some fileName -> 
  -            let dependencies = dependencies projectFile
  +            let dependencies = dependencyGraph.GetOrAdd(projectFile, dependencies)
   
               let assemblies =
                   extractedPackages
                   |> Seq.map snd
  -                |> Seq.filter (fun model -> dependencies |> Seq.contains model.PackageName)
  +                |> 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)
  
positive.code:                                     loadedLibs.Add(key,v)
                                      v
  
                              Some (assembly, BindingRedirects.getPublicKeyToken assembly)
                          with exn -> None)
                      |> 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.filter (fun a -> assembly.GetName().Name = a.Name)
                  |> Seq.exists (fun a -> assembly.GetName().Version > a.Version))
              |> Seq.map(fun (assembly, token) ->
                  { BindingRedirect.AssemblyName = assembly.GetName().Name
                    Version = assembly.GetName().Version.ToString()
                    PublicKeyToken = token
  
negative.code: open Paket.PackagesConfigFile
  open Paket.Requirements
  open System.Collections.Generic
  open System.Collections.Concurrent
  
  let updatePackagesConfigFile (model: Map<GroupName*PackageName,SemVerInfo*InstallSettings>) packagesConfigFileName =
      let packagesInConfigFile = PackagesConfigFile.Read packagesConfigFileName
  