anchor.diff:          r
   
       // Start by parsing the top-level value
  -    member x.Parse() = 
  +    member x.Parse() =
           let value = parseRootValue()
           skipWhitespace()
           if i <> s.Length then
               throw()
           value
   
  -    member x.ParseMultiple() = 
  +    member x.ParseMultiple() =
           seq {
               while i <> s.Length do
                   yield parseRootValue()
  -                skipWhitespace() 
  +                skipWhitespace()
           }
   
   type JsonValue with
   
     /// Parses the specified JSON string
  -  static member Parse(text, ?cultureInfo) = 
  +  static member Parse(text, ?cultureInfo) =
       JsonParser(text, cultureInfo, false).Parse()
   
     /// Loads JSON from the specified stream
  -  static member Load(stream:Stream, ?cultureInfo) = 
  +  static member Load(stream:Stream, ?cultureInfo) =
       use reader = new StreamReader(stream)
       let text = reader.ReadToEnd()
       JsonParser(text, cultureInfo, false).Parse()
   
     /// Loads JSON from the specified reader
  -  static member Load(reader:TextReader, ?cultureInfo) = 
  +  static member Load(reader:TextReader, ?cultureInfo) =
       let text = reader.ReadToEnd()
       JsonParser(text, cultureInfo, false).Parse()
   
  
positive.code:       httpMethod = httpMethod)
  
    [<Obsolete("Please use JsonValue.Request instead")>]
    member x.Post(uri:string, ?headers) =  
      x.Request(uri, ?headers = headers)
  
negative.code:                 | '"' -> buf.Append('"') |> ignore
                  | 'u' ->
                      ensure(i+5 < s.Length)
                      let hexdigit d =
                          if d >= '0' && d <= '9' then int32 d - int32 '0'
                          elif d >= 'a' && d <= 'f' then int32 d - int32 'a' + 10
                          elif d >= 'A' && d <= 'F' then int32 d - int32 'A' + 10
                          else failwith "hexdigit"
                      let unicodeChar (s:string) =
                          if s.Length <> 4 then failwith "unicodeChar";
                          char (hexdigit s.[0] * 4096 + hexdigit s.[1] * 256 + hexdigit s.[2] * 16 + hexdigit s.[3])
                      let ch = unicodeChar (s.Substring(i+2, 4))
                      buf.Append(ch) |> ignore
                      i <- i + 4  // the \ and u will also be skipped past further below
                  | _ -> throw()
                  i <- i + 2  // skip past \ and next char
  