anchor.diff:          
           let globalTargetsNodes =
               globalTargets
  -            |> Seq.collect (fun t -> t.FolderContents)
  +            |> Seq.collect (fun t -> t.Files.References)
               |> Seq.map (fun t -> t.Path)
               |> Seq.distinct
               |> Seq.filter (fun t -> String.endsWithIgnoreCase ".targets" t)
  
positive.code:             |> Set.ofList
  
          let model = model.FilterReferences references
          let createItemGroup (targets:TargetProfile list) (frameworkReferences:FrameworkReference list) (libraries:Library list) = 
              let itemGroup = createNode "ItemGroup" project
  
              for ref in frameworkReferences |> List.sortBy (fun f -> f.Name) do
                  createNode "Reference" project
                  |> addAttribute "Include" ref.Name
                  |> addChild (createNodeSet "Paket" "True" project)
                  |> itemGroup.AppendChild
                  |> ignore
              for lib in libraries |> List.sortBy (fun f -> f.Name) do
                  let fi = FileInfo (normalizePath lib.Path)
                  let aliases =
                      aliases
                      |> Map.tryPick (fun dll alias -> if fi.Name.Equals(dll, StringComparison.OrdinalIgnoreCase) then Some(alias) else None)
  
                  let relativePath = createRelativePath project.FileName fi.FullName
                  let privateSettings = 
                      match copyLocal with
                      | Some true -> "True" 
                      | Some false -> "False"
                      | None -> if relativePath.Contains @"\ref\" then "False" else "True"
  
                  if relativePath.Contains @"\native\" then createNode "NativeReference" project else createNode "Reference" project
                  |> addAttribute "Include" (fi.Name.Replace(fi.Extension,""))
                  |> addChild (createNodeSet "HintPath" relativePath project)
                  |> addChild (createNodeSet "Private" privateSettings project)
                  |> addChild (createNodeSet "Paket" "True" project)
                  |> fun n ->
                      match aliases with
                      | None -> n
                      | Some alias -> addChild (createNodeSet "Aliases" alias project) n
                  |> itemGroup.AppendChild
                  |> ignore
  
              itemGroup
  
          let createPropertyGroup (references:MsBuildFile list) = 
              let propertyGroup = createNode "PropertyGroup" project
                        
              let propertyNames =
                  references
                  |> Seq.map (fun lib ->
                      let targetsFile = lib.Path
                      let fi = new FileInfo(normalizePath targetsFile)
                      let propertyName = "__paket__" + fi.Name.ToString().Replace(" ","_").Replace(".","_")
  
                      let path = createRelativePath project.FileName (fi.FullName.Replace(fi.Extension,""))
                      let s = path.Substring(path.LastIndexOf("build\\") + 6)
                      let node = createNode propertyName project
                      node.InnerText <- s
                      node
                      |> propertyGroup.AppendChild 
                      |> ignore
                      propertyName,createRelativePath project.FileName fi.FullName,path.Substring(0,path.LastIndexOf("build\\") + 6))
                  |> Set.ofSeq
                      
              propertyNames,propertyGroup        
  
negative.code:                             | "$(TargetFrameworkIdentifier) == 'true'" -> "true"
                              | _ -> condition
  
  
                          let references = libFolder.Files.References |> Seq.sortBy (fun (r:Reference) -> r.Path) |> Seq.toList
                          let assemblyTargets = ref libFolder.Targets
                          let duplicates = HashSet<_>()
                          for lib in references do
                              match lib with
                              | Reference.FrameworkAssemblyReference frameworkAssembly ->
                                  for t in libFolder.Targets do
                                      if not <| usedFrameworkLibs.Add(t,frameworkAssembly) then
                                          assemblyTargets := List.filter ((<>) t) !assemblyTargets
                                          duplicates.Add lib |> ignore
                              | _ -> ()
  
                          if !assemblyTargets = libFolder.Targets then
                              [condition,createItemGroup libFolder.Targets references,false]
                          else
                              let frameworkAssemblies,rest = 
                                  references
                                  |> List.partition (fun lib -> 
                                      match lib with
                                      | Reference.FrameworkAssemblyReference frameworkAssembly -> duplicates.Contains lib
                                      | _ -> false)
  
                              match PlatformMatching.getCondition referenceCondition allTargets !assemblyTargets with
                              | "" -> [condition,createItemGroup libFolder.Targets rest,false]
                              | lowerCondition ->
                                  [lowerCondition,createItemGroup !assemblyTargets frameworkAssemblies,true
                                   condition,createItemGroup libFolder.Targets rest,false]
                          )
                          
          // global targets are targets, that are either directly in the /build folder,
          // or, if there is a framework-restriction, specific to the framework(s).
          // (ref https://docs.microsoft.com/en-us/nuget/create-packages/creating-a-package#including-msbuild-props-and-targets-in-a-package). 
          let globalTargets, frameworkSpecificTargets =
              if not importTargets then List.empty, List.empty else
              let sortedTargets = model.TargetsFileFolders |> List.sortBy (fun lib -> lib.Name)
              sortedTargets
              |> List.partition (fun lib -> "" = lib.Path.Name)
  
          let frameworkSpecificTargetsFileConditions =
              frameworkSpecificTargets
              |> List.map (fun lib -> PlatformMatching.getCondition referenceCondition allTargets lib.Targets,createPropertyGroup lib.Files.References)
  
          let chooseNodes =
              match conditions with
  