anchor.diff:  
           let refs =
             project.References
  -          |> Seq.choose Project.getAssemblyLocation
  +          |> Seq.collect Project.getAssemblyLocations
             |> Seq.append portableRefs
             |> Seq.toList
   
  
positive.code:           project.GetReferencedAssemblyProjects(getCurrentConfigurationOrDefault project)
            |> Seq.exists isPortable
  
        let getAssemblyLocation (reference:ProjectReference) =
            let tryGetFromHintPath() =
                if reference.HintPath.IsNotNull then 
                    let path = reference.HintPath.FullPath |> string
                    let path = path.Replace("/Library/Frameworks/Mono.framework/External",
                                            "/Library/Frameworks/Mono.framework/Versions/Current/lib/mono")
                    if File.Exists path then 
                        Some path 
                    else
                        // try and resolve from GAC
                        Some reference.HintPath.FileName
                else
                    None
  
            match reference.ReferenceType with
            | ReferenceType.Assembly ->
  
negative.code:               if isNull reference.Package then
                    tryGetFromHintPath()
                else 
                    if reference.Include <> "System" then
                        let assembly = 
                                reference.Package.Assemblies
                                |> Seq.find (fun a -> a.Name = reference.Include)
                        [assembly.Location]
                    else
                        reference.Package.Assemblies
                        |> Seq.map (fun a -> a.Location)
                        |> List.ofSeq
  
            | ReferenceType.Project -> 
                let referencedProject = reference.Project :?> DotNetProject
                let reference =
                    referencedProject.GetReferencedAssemblyProjects (getCurrentConfigurationOrDefault referencedProject)
                    |> Seq.tryFind(fun p -> p.Name = reference.Reference)
  
                match reference with
                    | Some ref ->
                        let output = ref.GetOutputFileName(getCurrentConfigurationOrDefault ref)
                        [output.FullPath.ToString()]
                    | _ -> []
            | _ -> []
  
        let getDefaultTargetFramework (runtime:TargetRuntime) =
            let newest_net_framework_folder (best:TargetFramework,best_version:int[]) (candidate_framework:TargetFramework) =
  