anchor.diff:                  directDependencies 
                   |> Seq.collect (fun u -> lookup.[u.Key] |> Seq.map (fun i -> fst u.Key, u.Value, i))
                   |> Seq.partitionAndChoose 
  -                        (fun (groupName,(_,parentSettings), dep) -> 
  -                            lockFile.Groups |> Map.containsKey groupName)
  -                        (fun (groupName,(_,parentSettings), dep) -> 
  -                            let group = lockFile.Groups.[groupName]
  -                            match group.Resolution |> Map.tryFind dep with
  -                            | None -> None
  -                            | Some p -> 
  -                                let resolvedSettings = 
  -                                    [p.Settings; group.Options.Settings] 
  -                                    |> List.fold (+) parentSettings
  -                                Some ((groupName,p.Name), (p.Version,resolvedSettings)) )
  -                        (fun (groupName,(_,parentSettings), dep) -> 
  -                            Some <| sprintf "%s uses the group %O, but this group was not found in paket.lock." referenceFile.FileName groupName
  -                        )
  +                    (fun (groupName,(_,parentSettings), dep) -> 
  +                        lockFile.Groups |> Map.containsKey groupName)
  +                    (fun (groupName,(_,parentSettings), dep) -> 
  +                        let group = lockFile.Groups.[groupName]
  +                        match group.Resolution |> Map.tryFind dep with
  +                        | None -> None
  +                        | Some p -> 
  +                            let resolvedSettings = 
  +                                [p.Settings; group.Options.Settings] 
  +                                |> List.fold (+) parentSettings
  +                            Some ((groupName,p.Name), (p.Version,resolvedSettings)) )
  +                    (fun (groupName,(_,parentSettings), dep) -> 
  +                        Some <| sprintf " - %s uses the group %O, but this group was not found in paket.lock." referenceFile.FileName groupName
  +                    )
               for key,settings in usedPackageDependencies do
                   if d.ContainsKey key |> not then
                       d <- Map.add key settings d
  
positive.code:                     true)
              |> fun usedPackages -> usedPackages, Seq.append errorMessages errors
  
          // if any errors have been found during the installation process thus far, fail and print all errors collected
          if not (Seq.isEmpty errorMessages) then 
              failwithf  "Installation Failed :\n%s" (String.concat "\n" errorMessages)
          else
              if toolsVersion >= 15.0 then 
                  installForDotnetSDK root project  
              else
  
negative.code:                 |> updatePackagesConfigFile usedPackages 
  
              let gitRemoteItems =
                  gitRemotePathPairs 
                  |> Seq.map (fun (file,remoteFilePath) -> 
                      let link = if file.Link = "." then Path.GetFileName file.Name else Path.Combine(file.Link, Path.GetFileName file.Name)
                      if verbose then
                          tracefn "FileName: %s " file.Name 
      
                      let linked = defaultArg file.Settings.Link true
                      let buildAction = project.DetermineBuildActionForRemoteItems file.Name
                      if buildAction <> BuildAction.Reference && linked then
                          {   BuildAction = buildAction
                              Include = createRelativePath project.FileName remoteFilePath
                              WithPaketSubNode = true
                              CopyToOutputDirectory = None
                              Link = Some link 
                          }
                      else
                          {   BuildAction = buildAction
                              WithPaketSubNode = true
                              CopyToOutputDirectory = None
                              Include =
                                  if buildAction = BuildAction.Reference then
                                      createRelativePath project.FileName remoteFilePath
                                  else
                                      let toDir = Path.GetDirectoryName(project.FileName)
                                      let targetFile = FileInfo(Path.Combine(toDir,link))
  