anchor.diff:              | e -> raise <| new SerializationException(sprintf "Error deserializing instance of type '%O'." typeof<'T>, e)
   
           member internal r.ReadRootObject(f : Pickler<'T>, id : string) =
  +            if br.ReadByte() <> ObjHeader.initByte then
  +                raise <| new SerializationException ("FsPickler: invalid stream data.")
  +
               let id' = br.ReadString()
               if id <> id' then
                   let msg = sprintf "FsPickler: Root object is of type '%s', expected '%s'." id' id
                   raise <| new SerializationException(msg)
  +
               r.Read f
   
           // efficient sequence deserialization; must be used as top-level operation only
  -        member internal r.ReadSequence<'T> (f : Pickler<'T>, id : string, length : int) =
  +        member internal r.ReadSequence<'T> (pickler : Pickler<'T>, id : string, length : int) =
               let inline flushState () =
                   objCache.Clear ()
                   counter <- 1L
   
  -            let isPrimitive = f.TypeKind = TypeKind.Primitive
  -            let isNonAtomic = f.PicklerInfo <> PicklerInfo.Atomic
  +            let isPrimitive = pickler.TypeKind = TypeKind.Primitive
  +            let isNonAtomic = pickler.PicklerInfo <> PicklerInfo.Atomic
   
               let read idx =
  -                if isPrimitive then f.Read r
  +                if isPrimitive then pickler.Read r
                   elif isNonAtomic then
                       if idx % sequenceCounterResetThreshold = 0 then
                           flushState ()
  -                    r.Read f
  +                    r.Read pickler
                   elif br.ReadBoolean () then fastUnbox<'T> null
                   else
  -                    f.Read r
  +                    pickler.Read r
   
               // read id
               let id' = br.ReadString()
  
positive.code:                 raise <| new SerializationException(msg)
              
              // read object header
              match ObjHeader.read f.Type f.PicklerFlags (br.ReadUInt32()) with
              | ObjHeader.isSequenceHeader -> ()
              | _ -> 
                  let msg = "FsPickler: invalid stream data; expected sequence serialization."
  
negative.code: 
                              if t.IsArray then
                                  writeHeader ObjHeader.isOldCachedInstance
                              elif t <> pickler.Type then
                                  writeHeader (ObjHeader.isCyclicInstance ||| ObjHeader.isProperSubtype)
                                  writeType t
                              else
  