anchor.diff:          member internal w.Resolver = resolver
   
           // the primary serialization routine; handles all the caching, subtype resolution logic, etc
  -        member w.Write<'T> (fmt : Pickler<'T>, x : 'T) =
  +        member w.Write<'T> (pickler : Pickler<'T>, x : 'T) =
   
               let inline writeHeader (flags : byte) =
  -                bw.Write(ObjHeader.create fmt.PicklerFlags flags)
  +                bw.Write(ObjHeader.create pickler.PicklerFlags flags)
   
               // ad-hoc System.Type caching
               let inline writeType (t : Type) =
  
positive.code:                 do RuntimeHelpers.EnsureSufficientExecutionStack()
  #endif
  
                  if fmt.IsCacheByRef || fmt.IsCyclicType then
                      let id, firstOccurence = idGen.GetId x
  
                      if firstOccurence then
                          if fmt.IsCyclicType then 
                              // push id to the symbolic stack to detect cyclic objects during traversal
                              objStack.Push id
  
  
negative.code: 
                  elif ObjHeader.hasFlag flags ObjHeader.isNewCachedInstance then
                      let id = counter
                      if pickler.TypeKind = TypeKind.Array || pickler.TypeKind = TypeKind.ArrayCompatible then
                          currentDeserializedArrayId <- id
                      counter <- counter + 1L
  
                      let x = read flags
  
                      if pickler.IsCyclicType then 
                          let found, contents = fixupIndex.TryGetValue id
  
                          if found then
  