anchor.diff:  
           let assemblies =
               extractedPackages
  -            |> Seq.map snd
  -            |> Seq.filter (fun model -> dependencies |> Set.contains model.PackageName)
  -            |> Seq.collect (fun model -> model.GetLibReferences(projectFile.GetTargetProfile()))
  -            |> Seq.groupBy (fun p -> FileInfo(p).Name)
  +            |> Seq.filter (fun (model,_) -> dependencies |> Set.contains model.PackageName)
  +            |> Seq.collect (fun (model,redirects) -> model.GetLibReferences(projectFile.GetTargetProfile()) |> Seq.map (fun lib -> lib,redirects))
  +            |> Seq.groupBy (fun (p,_) -> FileInfo(p).Name)
               |> Seq.choose(fun (_,librariesForPackage) ->
                   librariesForPackage
  -                |> Seq.choose(fun library ->
  +                |> Seq.choose(fun (library,redirects) ->
                       try
                           let key = FileInfo(library).FullName.ToLowerInvariant()
                           let assembly = 
  
positive.code:     extractedPackages
  
  /// Applies binding redirects for all strong-named references to all app. and web.config files.
  let private applyBindingRedirects (loadedLibs:Dictionary<_,_>) isFirstGroup createNewBindingFiles cleanBindingRedirects root groupName findDependencies (extractedPackages:seq<_*InstallModel>) =
      let dependencyGraph = ConcurrentDictionary<_,Set<_>>()
      let projects = ConcurrentDictionary<_,ProjectFile option>();
  
  
negative.code:                                 loadedLibs.Add(key,v)
                                  v
  
                          Some (assembly, BindingRedirects.getPublicKeyToken assembly, assembly.GetReferencedAssemblies(), redirects)
                      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,refs,redirects) -> token |> Option.map (fun token -> (assembly,token,refs,redirects)))
          |> Seq.filter (fun (assembly,_,refs,redirects) -> 
              redirects = Some Force
              || 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,_,_) ->
              { BindingRedirect.AssemblyName = assembly.GetName().Name
                Version = assembly.GetName().Version.ToString()
                PublicKeyToken = token
  