anchor.diff:                      raise <| new FormatException("Xml document ended prematurely.")
   
               member inline r.SkipWhitespace() =
  -                while r.NodeType = XmlNodeType.Whitespace || r.NodeType = XmlNodeType.SignificantWhitespace do
  -                    r.MoveNext()
  +                while
  +                   (match r.NodeType with
  +                    | XmlNodeType.Whitespace
  +                    | XmlNodeType.SignificantWhitespace
  +                    | XmlNodeType.Comment -> true
  +                    | _ -> false) 
  +                    
  +                    do r.MoveNext()
  +
  +            member inline r.ReadElementName (tag : string) =
  +                do r.SkipWhitespace()
  +
  +                if r.NodeType <> XmlNodeType.Element then
  +                    let msg = sprintf "expected token '%O' but was '%O'." XmlNodeType.Element r.NodeType
  +                    raise <| new FormatException(msg)
  +
  +                elif r.Name <> tag then
  +                    let msg = sprintf "expected element '%s' but was '%s'." tag r.Name
  +                    raise <| new FormatException(msg)
   
   
       open XmlUtils
  
positive.code:     open Microsoft.FSharp.Core.LanguagePrimitives
  
      module private XmlUtils =
  
          let inline writePrimitive (w : ^XmlWriter) (tag : string) (value : ^T) =
              (^XmlWriter : (member WriteStartElement : string -> unit) (w, tag))
              (^XmlWriter : (member WriteValue : ^T -> unit) (w, value))
              (^XmlWriter : (member WriteEndElement : unit -> unit) w)
  
          let inline readElementName (r : XmlReader) (tag : string) =
              while r.NodeType <> XmlNodeType.Element && r.Read() do ()
  
              if r.NodeType <> XmlNodeType.Element then
                  raise <| new InvalidDataException()
  
              elif r.Name <> tag then
                  let msg = sprintf "expected type '%s' but was '%s'" tag r.Name
                  raise <| new FsPicklerException(msg)
  
          let inline escapeString (value : string) = SecurityElement.Escape value
          let inline unEscapeString (value : string) =
  
negative.code: 
              member __.EndReadRoot () =
                  if reader.IsEmptyElement then
                      reader.MoveNext()
                  else
                      reader.ReadEndElement()
  
              member __.BeginReadObject (tag : string) =
                  do reader.ReadElementName tag
  
                  let flags = parseFlagCsv <| reader.["flags"]
  
  