anchor.diff:          |> Seq.collect getCompileRefs
           |> Seq.map getCompileItem
           |> Seq.collect getRealItems
  -
  -
  -    member self.GetTemplateMetadata () =
  -        let prop name = self.GetProperty name
  -        
  -        let propOr name value =
  -            defaultArg (self.GetProperty name) value
  -        
  -        let propMap name value fn =
  -            defaultArg (self.GetProperty name|>Option.map fn) value
  -        
  -        let tryBool = Boolean.TryParse>>function true, value-> value| _ -> false
  -        
  -        let splitString = String.split[|';'|]>>List.ofArray
  -
  -        let coreInfo : ProjectCoreInfo = {
  -            Id = prop "id" 
  -            Version = propMap "version" (Some(SemVer.Parse "0.0.1")) (SemVer.Parse>>Some)
  -            Authors = propMap "Authors" None (splitString>>Some)
  -            Description = prop "Description" 
  -            Symbols = propMap "Symbols" false tryBool
  -        }
  -        let optionalInfo =  {
  -            Title = prop "Title"
  -            Owners = propMap "Owners" [] (String.split[|';'|]>>List.ofArray)
  -            ReleaseNotes = prop "ReleaseNores"
  -            Summary = prop "Summary"
  -            Language = prop "Langauge"
  -            ProjectUrl = prop "ProjectUrl"
  -            IconUrl = prop "IconUrl"
  -            LicenseUrl = prop "LicenseUrl"
  -            Copyright = prop  "Copyright" 
  -            RequireLicenseAcceptance = propMap "RequireLicenseAcceptance" false tryBool
  -            Tags = propMap "Tags" [] splitString
  -            DevelopmentDependency = propMap "DevelopmentDependency" false tryBool
  -            Dependencies = [] //propOr "Dependencies" []
  -            ExcludedDependencies = Set.empty //propOr "ExcludedDependencies" 
  -            ExcludedGroups = Set.empty // propOr "ExcludedGroups" Set.empty
  -            References = [] //propOr "References" []
  -            FrameworkAssemblyReferences = [] //propOr "FrameworkAssemblyReferences" []
  -            Files = [] //propMap "Files" [] splitString
  -            FilesExcluded = [] //propMap  "FilesExcluded" [] splitString
  -            IncludePdbs = propMap "IncludePdbs" true tryBool
  -            IncludeReferencedProjects = propMap "IncludeReferencedProjects" true tryBool
  -        }
  -        
  -        (coreInfo, optionalInfo)
  -        
positive.code:         
          let globalTargetsNodes =
              globalTargets
              |> Seq.collect (fun t -> t.FolderContents)
              |> Seq.map (fun t -> t.Path)
              |> Seq.distinct
              |> Seq.filter (fun t -> String.endsWithIgnoreCase ".targets" t)
  
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
  