anchor.diff:          |> Array.map (fun (p,m) -> NormalizedPackageName p.Name,p)
           |> Map.ofArray
   
  -    for project : ProjectFile, referenceFile in projects do    
  +    for project : ProjectFile, referenceFile in projects do
           verbosefn "Installing to %s" project.FileName
  -        
  +
           let usedPackages =
               lockFile.GetPackageHull(referenceFile)
  -            |> Seq.map (fun u -> 
  +            |> Seq.map (fun u ->
                   let package = packages.[NormalizedPackageName u.Key]
  -                let referenceFileSettings = 
  +                let referenceFileSettings =
                       referenceFile.NugetPackages
                       |> List.tryFind (fun x -> NormalizedPackageName x.Name = NormalizedPackageName u.Key)
  -                let copyLocal =                
  +                let copyLocal =
                       match referenceFileSettings with
                       | Some s -> s.Settings.CopyLocal
                       | None -> None
  -                let omitContent =                
  +                let omitContent =
                       match referenceFileSettings with
                       | Some s -> s.Settings.OmitContent
                       | None -> None
  -                let importTargets =                
  +                let importTargets =
                       match referenceFileSettings with
                       | Some s -> s.Settings.ImportTargets
                       | None -> None
  -                let restriktions =                
  +                let restriktions =
                       match referenceFileSettings with
                       | Some s -> s.Settings.FrameworkRestrictions
                       | None -> []
  
positive.code: 
          removeCopiedFiles project
  
          let getSingleRemoteFilePath name = 
              traceVerbose <| sprintf "Filename %s " name
              lockFile.SourceFiles |> List.iter (fun i -> traceVerbose <| sprintf " %s %s " i.Name (i.FilePath root))
              let sourceFile = lockFile.SourceFiles |> List.tryFind (fun f -> Path.GetFileName(f.Name) = name)
  
negative.code:     }
  
  /// Restores the given packages from the lock file.
  let createModel(root, sources, force, lockFile : LockFile) =
      let sourceFileDownloads = RemoteDownload.DownloadSourceFiles(root, lockFile.SourceFiles)
  
      let packageDownloads =
          lockFile.ResolvedPackages
          |> Seq.map (fun kv -> CreateInstallModel(root,sources,force,kv.Value))
          |> Async.Parallel
  