anchor.diff:              removeEmptyDirHierarchy dir.Parent
   
       let removeFilesAndTrimDirs (files: FileInfo list) =
  -        for f in files do 
  -            if f.Exists then 
  +        for f in files do
  +            if f.Exists then
                   f.Delete()
   
  -        let dirsPathsDeepestFirst = 
  +        let dirsPathsDeepestFirst =
               files
               |> Seq.map (fun f -> f.Directory.FullName)
               |> Seq.distinct
               |> List.ofSeq
               |> List.rev
  -        
  +
           for dirPath in dirsPathsDeepestFirst do
               removeEmptyDirHierarchy (DirectoryInfo dirPath)
   
  -    project.GetPaketFileItems() 
  +    project.GetPaketFileItems()
       |> List.filter (fun fi -> not <| fi.FullName.Contains(Constants.PaketFilesFolderName))
       |> removeFilesAndTrimDirs
   
  -let CreateInstallModel(root, sources, force, package) = 
  -    async { 
  +let CreateInstallModel(root, sources, force, package) =
  +    async {
           let! (package, files, targetsFiles) = RestoreProcess.ExtractPackage(root, sources, force, package)
  -        let (PackageName name) = package.Name        
  +        let (PackageName name) = package.Name
           let nuspec = Nuspec.Load(root,package.Name)
           let files = files |> Array.map (fun fi -> fi.FullName)
           let targetsFiles = targetsFiles |> Array.map (fun fi -> fi.FullName)
  
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:     |> ProjectFile.FindAllProjects
      |> Array.choose (fun p -> ProjectFile.FindReferencesFile(FileInfo(p.FileName))
                                  |> Option.map (fun r -> p, r))
      |> Array.map (fun (project,file) ->
          try
              ok <| (project, ReferencesFile.FromFile(file))
          with _ ->
              fail <| ReferencesFileParseError (FileInfo(file)))
      |> collect
  
  /// Installs all packages from the lock file.
  let InstallIntoProjectsNew(sources, options : CommonOptions, lockFile : LockFile, projects) =
      let root = Path.GetDirectoryName lockFile.FileName
      let extractedPackages = createModel(root, sources, options.Force, lockFile)
  
      let model =
          extractedPackages
  