anchor.diff:                  | "true" -> Some ResolverStrategy.Min
                   | _ -> None
   
  -            ParserOptions(ParserOption.ResolverStrategyForDirectDependencies(setting))
  +            Some (ParserOptions(ParserOption.ResolverStrategyForDirectDependencies(setting)))
           | String.StartsWith "framework" trimmed -> 
               let text = trimmed.Replace(":", "").Trim()
               
               if text = "auto-detect" then 
  -                ParserOptions(ParserOption.AutodetectFrameworkRestrictions)
  +                Some (ParserOptions(ParserOption.AutodetectFrameworkRestrictions))
               else 
                   let restrictions = Requirements.parseRestrictions text
                   if String.IsNullOrWhiteSpace text |> not && List.isEmpty restrictions then 
                       failwithf "Could not parse framework restriction \"%s\"" text
   
                   let options = ParserOption.FrameworkRestrictions(FrameworkRestrictionList restrictions)
  -                ParserOptions options
  +                Some (ParserOptions options)
   
           | String.StartsWith "content" trimmed -> 
               let setting =
  
positive.code:                             let relative = (createRelativePath root fullPath).Replace("\\","/")
                              LocalNuGet(relative,None) :: current.Sources |> List.distinct 
                      lineNo, { current with RemoteFiles = current.RemoteFiles @ [remoteFile]; Sources = sources }::other
              with
              | exn -> failwithf "Error in paket.dependencies line %d%s  %s" lineNo Environment.NewLine exn.Message
          | [] -> failwithf "Error in paket.dependencies line %d" lineNo
  
negative.code:     | PackageSource of PackageSource
      | Cache of Cache
  
      let private removeComment (text:string) =
          match text.IndexOf("//") with
          | -1 ->
              match text.IndexOf("#") with
              | -1 -> text
              | p -> 
                  let f = text.Substring(0,p).Trim()
                  printfn "%s" f
                  f
          | p -> 
              let f = text.Substring(0,p).Trim()
              printfn "%s" f
              f 
  
      let private (|Remote|_|) (line:string) =
          let trimmed = line.Trim() 
          match trimmed with
          | String.StartsWith "source" _ as trimmed -> 
              try 
                  let source = PackageSource.Parse(trimmed)
                  Some (Remote(RemoteParserOption.PackageSource(source)))
              with e -> 
                  traceWarnfn "could not parse package source %s (%s)" trimmed e.Message
                  reraise ()
          | String.StartsWith "cache" _ as trimmed -> Some (Remote(RemoteParserOption.Cache(Cache.Parse(trimmed))))
          | _ -> None
          
      let private (|Package|_|) (line:string) =
          let trimmed = line.Trim() 
          match trimmed with
          | String.StartsWith "nuget" trimmed -> 
              let parts = trimmed.Trim().Replace("\"", "").Split([|' '|],StringSplitOptions.RemoveEmptyEntries) |> Seq.toList
  
  