anchor.diff:                          else
                               write ObjHeader.isNewCachedInstance
   
  -                    elif fmt.IsCyclicType && objStack.Contains id && not <| cyclicObjects.Contains id then
  +                    elif pickler.IsCyclicType && objStack.Contains id && not <| cyclicObjects.Contains id then
                           // came across cyclic object, record fixup-related data
                           // cyclic objects are handled once per instance
                           // instances of cyclic arrays are handled differently than other reference types
   
                           do cyclicObjects.Add(id) |> ignore
                       
  -                        if fmt.TypeKind <= TypeKind.Sealed || fmt.UseWithSubtypes then
  -                            if fmt.TypeKind = TypeKind.Array then
  +                        if pickler.TypeKind <= TypeKind.Sealed || pickler.UseWithSubtypes then
  +                            if pickler.TypeKind = TypeKind.Array then
                                   writeHeader ObjHeader.isOldCachedInstance
                               else
                                   writeHeader ObjHeader.isCyclicInstance
  
positive.code: 
                  elif ObjHeader.hasFlag flags ObjHeader.isNewCachedInstance then
                      let id = counter
                      if fmt.TypeKind = TypeKind.Array || fmt.TypeKind = TypeKind.ArrayCompatible then
                          currentDeserializedArrayId <- id
                      counter <- counter + 1L
  
                      let x = read flags
  
                      if fmt.IsCyclicType then 
                          let found, contents = fixupIndex.TryGetValue id
  
                          if found then
  
negative.code:         member internal w.Resolver = resolver
  
          // the primary serialization routine; handles all the caching, subtype resolution logic, etc
          member w.Write<'T> (pickler : Pickler<'T>, x : 'T) =
  
              let inline writeHeader (flags : byte) =
                  bw.Write(ObjHeader.create pickler.PicklerFlags flags)
  
              // ad-hoc System.Type caching
              let inline writeType (t : Type) =
  