anchor.diff:                          'message-descriptor)
                    (if (eq (proto-message-type msg) :group)
                        (doseq (v (if slot (read-slot object slot reader) (list object)))
  -                       ;; To serialize a group, we encode a start tag,
  -                       ;; serialize the fields, then encode an end tag
  -                       (let ((tag1 (make-tag $wire-type-start-group index))
  -                             (tag2 (make-tag $wire-type-end-group   index)))
  -                         (iincf size (encode-uint32 tag1 buffer))
  -                         (dolist (f (proto-fields msg))
  -                           (iincf size (emit-field v f buffer)))
  -                         (iincf size (encode-uint32 tag2 buffer))))
  +                            ;; To serialize a group, we encode a start tag,
  +                            ;; serialize the fields, then encode an end tag
  +                            (let ((tag1 (make-tag $wire-type-start-group index))
  +                                  (tag2 (make-tag $wire-type-end-group   index)))
  +                              (iincf size (encode-uint32 tag1 buffer))
  +                              (dolist (f (proto-fields msg))
  +                                (iincf size (emit-field v f buffer)))
  +                              (iincf size (encode-uint32 tag2 buffer))))
                        ;; I don't understand this at all - if there is a slot, then the slot
                        ;; holds a list of objects, otherwise just serialize this object?
                        (let ((tag (make-tag $wire-type-string index))
  
positive.code:     (dolist (field (proto-fields msg-desc) size)
        (iincf size (emit-field object field buffer)))))
  
  (macrolet ((read-slot (object slot reader)
               ;; Don't do a boundp check, we assume the object is fully populated
               ;; Unpopulated slots should be "nullable" and will contain nil when empty
               `(if ,reader
                    (funcall ,reader ,object)
                    (slot-value ,object ,slot))))
    (defun emit-field (object field buffer)
      "Serialize FIELD in OBJECT to BUFFER"
      (declare (type field-descriptor field))
      (unless
          (if (eq (slot-value field 'message-type) :extends)
              (has-extension object (slot-value field 'internal-field-name))
  
negative.code:                                                 (and (not (proto-lazy-p field))
                                                       reader))
                                       (list object)))
                                ;; To serialize an embedded message, first say that it's
                                ;; a string, then encode its size, then serialize its fields
                                (iincf size (encode-uint32 tag buffer))
                                (let ((submessage-size 0))
                                  (with-placeholder (buffer)
                                    (if custom-serializer
                                        (iincf submessage-size
                                               (funcall custom-serializer v buffer))
                                        (dolist (f (proto-fields msg))
                                          (iincf submessage-size (emit-field v f buffer))))
                                    (iincf size (+ (backpatch submessage-size)
                                                   submessage-size)))))))
                   size)
                  ((typep msg 'protobuf-enum)
                   ;; 'proto-packed-p' of enum types returns nil,
  