anchor.diff:          this.AddOrReplaceGroup(
               framework.Group,
               (fun group ->
  -                { group with Frameworks = 
  -                                match Map.tryFind framework group.Frameworks with
  -                                | Some files -> 
  -                                    Map.add framework 
  -                                        (files.AddFrameworkAssemblyReference assemblyName) 
  -                                        group.Frameworks
  -                                | None -> 
  -                                    Map.add framework 
  -                                        (InstallFiles.empty.AddFrameworkAssemblyReference assemblyName) 
  -                                        group.Frameworks }),
  +                group.ReplaceFramework(
  +                    framework,
  +                    (fun files -> files.AddFrameworkAssemblyReference assemblyName),
  +                    (fun _ -> Some (InstallFiles.empty.AddFrameworkAssemblyReference assemblyName)))),
               (fun _ -> None))
       
       member this.AddFrameworkAssemblyReferences(references) : InstallModel = 
           references 
           |> Seq.fold 
  -               (fun model reference -> 
  -               model.AddFrameworkAssemblyReference(reference.TargetFramework, reference.AssemblyName)) this
  +               (fun model reference -> model.AddFrameworkAssemblyReference(reference.TargetFramework, reference.AssemblyName))
  +                this
       
       member this.FilterBlackList() = 
           let blackList = 
  
positive.code:                 match reference with
                  | Reference.Library lib -> not (lib.EndsWith ".dll" || lib.EndsWith ".exe")
                  | _ -> false ]
          { this with Groups = 
                          this.Groups 
                          |> Map.map 
  
negative.code:         else 
              FrameworkIdentifier.KnownSpecialTargets 
              |> List.fold (fun (model : InstallModel) framework -> 
                      model.AddOrReplaceGroup(
                          framework.Group,
                          (fun group ->
                              match Map.tryFind framework group.Frameworks with
                              | Some files when Set.isEmpty files.References -> 
                                  { group with Frameworks = 
                                                  Map.add framework { References = newFiles
                                                                      ContentFiles = Set.empty } 
                                                      group.Frameworks }
                              | None -> 
                                  { group with Frameworks = 
                                                  Map.add framework { References = newFiles
                                                                      ContentFiles = Set.empty } 
                                                      group.Frameworks }
                              | _ -> group),
                          (fun _ -> Some ({ Frameworks = Map.add framework { References = newFiles; ContentFiles = Set.empty } Map.empty
                                            Fallbacks = InstallFiles.empty })))) this
      
      member this.UseLastInGroupAsFallback() = 
          let groups = 
  