anchor.diff:                              | _-> packages.Add(parsePackageInstallSettings line)
                           packages |> Seq.toList
   
  -                    let remoteFiles = 
  +                    let remoteFiles =
                           remoteLines
  -                        |> List.map (fun s -> s.Replace("File:","").Split([|' '|], StringSplitOptions.RemoveEmptyEntries))
                           |> List.map (fun segments ->
  +                                        let segments = s.Replace("File:","").Split([|' '|], StringSplitOptions.RemoveEmptyEntries)
                                           let hasPath =
                                               let get x = if segments.Length > x then segments.[x] else ""
  -                                            segments.Length >= 2 && not ((get 1).Contains(":")) && not ((get 2).StartsWith(":")) 
  -
  -                                        let rest = 
  +                                            segments.Length >= 2 && not ((get 1).Contains(":")) && not ((get 2).StartsWith(":"))
  +
  +                                        let rest =
                                               let skip = if hasPath then 2 else 1
                                               if segments.Length < skip then "" else String.Join(" ",segments |> Seq.skip skip)
   
                                           { Name = segments.[0]
  -                                          Link = if hasPath then segments.[1] else ReferencesFile.DefaultLink 
  +                                          Link = if hasPath then segments.[1] else ReferencesFile.DefaultLink
                                             Settings = RemoteFileInstallSettings.Parse rest })
                       { Name = groupName; NugetPackages = nugetPackages; RemoteFiles = remoteFiles })
  -            |> List.fold (fun m g -> 
  +            |> List.fold (fun m g ->
                   match Map.tryFind g.Name m with
                   | None -> Map.add g.Name g m
  -                | Some group -> 
  -                    let newGroup = 
  +                | Some group ->
  +                    let newGroup =
                           { Name = g.Name
                             NugetPackages = g.NugetPackages @ group.NugetPackages
                             RemoteFiles = g.RemoteFiles @ group.RemoteFiles }
  
positive.code: 
                  { this with Groups = newGroups }
  
          | Some group -> 
              if group.NugetPackages |> Seq.exists (fun p -> p.Name = packageName) then
                  this
              else
  
negative.code:                     Simplify = None } }
  
          match this.Groups |> Map.tryFind groupName with
          | None ->
                  tracefn "Adding package %O to %s into new group %O" packageName this.FileName groupName
  
                  let newGroup =
                      { Name = groupName
                        NugetPackages = [ package ]
                        RemoteFiles = [] }
  