anchor.diff:      | Some x -> x
       | None -> failwithf "Package directory for package %s was not found." name
   
  -let private findPackagesWithContent (root,usedPackages:Map<PackageName,PackageInstallSettings>) = 
  +let private findPackagesWithContent (root,usedPackages:Map<PackageName,PackageInstallSettings>) =
       usedPackages
       |> Seq.filter (fun kv -> defaultArg kv.Value.Settings.OmitContent false |> not)
       |> Seq.map (fun kv -> findPackageFolder root kv.Key)
  -    |> Seq.choose (fun packageDir -> 
  -            packageDir.GetDirectories("Content") 
  +    |> Seq.choose (fun packageDir ->
  +            packageDir.GetDirectories("Content")
               |> Array.append (packageDir.GetDirectories("content"))
               |> Array.tryFind (fun _ -> true))
       |> Seq.toList
   
  -let private copyContentFiles (project : ProjectFile, packagesWithContent) = 
  +let private copyContentFiles (project : ProjectFile, packagesWithContent) =
   
       let rules : list<(FileInfo -> bool)> = [
               fun f -> f.Name = "_._"
  
positive.code: 
          let gitRemoteItems =
              referenceFile.RemoteFiles
              |> List.map (fun file -> 
                               { BuildAction = project.DetermineBuildAction file.Name 
                                 Include = createRelativePath project.FileName (getSingleRemoteFilePath file.Name)
                                 Link = Some(if file.Link = "." then Path.GetFileName(file.Name)
                                             else Path.Combine(file.Link, Path.GetFileName(file.Name))) })
          
          let nuGetFileItems =
              copyContentFiles(project, findPackagesWithContent(root,usedPackages))
              |> List.map (fun file -> 
                                  { BuildAction = project.DetermineBuildAction file.Name
                                    Include = createRelativePath project.FileName file.FullName
                                    Link = None })
  
negative.code:         |> Array.map (fun (p,m) -> NormalizedPackageName p.Name,p)
          |> Map.ofArray
  
      for project : ProjectFile, referenceFile in projects do
          verbosefn "Installing to %s" project.FileName
  
          let usedPackages =
              lockFile.GetPackageHull(referenceFile)
              |> Seq.map (fun u ->
                  let package = packages.[NormalizedPackageName u.Key]
                  let referenceFileSettings =
                      referenceFile.NugetPackages
                      |> List.tryFind (fun x -> NormalizedPackageName x.Name = NormalizedPackageName u.Key)
                  let copyLocal =
                      match referenceFileSettings with
                      | Some s -> s.Settings.CopyLocal
                      | None -> None
                  let omitContent =
                      match referenceFileSettings with
                      | Some s -> s.Settings.OmitContent
                      | None -> None
                  let importTargets =
                      match referenceFileSettings with
                      | Some s -> s.Settings.ImportTargets
                      | None -> None
                  let restriktions =
                      match referenceFileSettings with
                      | Some s -> s.Settings.FrameworkRestrictions
                      | None -> []
  