anchor.diff:  
   
           // the primary deserialization routine; handles all the caching, subtype resolution logic, etc
  -        member r.Read(fmt : Pickler<'T>) : 'T =
  +        member r.Read(pickler : Pickler<'T>) : 'T =
   
               // ad-hoc System.Type caching
               let inline readType () =
  
positive.code:                     bw.Write id
  
              let inline write header =
                  if fmt.TypeKind <= TypeKind.Sealed || fmt.UseWithSubtypes then
                      writeHeader header
                      fmt.Write w x
                  else
                      // object might be of proper subtype, perform reflection resolution
                      let t0 = x.GetType()
                      if t0 <> fmt.Type then
                          let fmt' = resolver.Resolve t0
                          writeHeader (header ||| ObjHeader.isProperSubtype)
                          writeType t0
                          fmt'.UntypedWrite(w, x, managed = false)
                      else
                          writeHeader header
                          fmt.Write w x
  
              try
                  if fmt.TypeKind <= TypeKind.Value then 
                      writeHeader ObjHeader.empty
                      fmt.Write w x
  
                  elif obj.ReferenceEquals(x, null) then writeHeader ObjHeader.isNull else
  
  
negative.code:                 raise <| new SerializationException(msg)
              
              // read object header
              match ObjHeader.read pickler.Type pickler.PicklerFlags (br.ReadUInt32()) with
              | ObjHeader.isSequenceHeader -> ()
              | _ -> 
                  let msg = "FsPickler: invalid stream data; expected sequence serialization."
  