anchor.diff:                                      (when (non-repeated-bool-field field)
                                         (incf bool-index))
                                       :bool-values bool-values)
  -             (incf field-offset)
  +             (declare (ignore offset-p))
  +             (when offset-p
  +               (incf field-offset))
                (if (proto-lazy-p field)
                    (collect-lazy-field field)
                    (collect-non-lazy-field field))
  
positive.code:                `(setf (bit (,bit-field-name ,obj) ,bool-index)
                        ,(if default-form 1 0))
                 `(setf (,hidden-accessor-name ,obj) ,default-form))
            (setf (bit (,is-set-accessor ,obj) ,index) 0))
  
          ;; Create defmethods to allow for getting/setting compatibly
          ;; with the standard-classes.
  
negative.code:         (bit-field-name (fintern "~A-%%BOOL-VALUES" proto-type))
          (label (proto-label field)))
  
      ;; If index is unbound, then this field does not have a reserved bit in the %%is-set vector.
      ;; This means that the field is singular, so checking for field presence must be done by
      ;; checking if the bound value is default.
      (with-gensyms (obj new-value cur-value)
        `(
          (declaim (inline (setf ,public-accessor-name)))
          (defun (setf ,public-accessor-name) (,new-value ,obj)
            ,(when index
               `(setf (bit (,is-set-accessor ,obj) ,index) 1))
            ,(if bool-index
                 `(setf (bit (,bit-field-name ,obj) ,bool-index)
                        (if ,new-value 1 0))
                 `(setf (,hidden-accessor-name ,obj) ,new-value)))
  
  
          ;; For singular fields, the has-* function is repurposed. It now answers the question:
          ;; "Is this field bound to the default value?". This is done so that the optimized
          ;; serializer can use the has-* function to check if a singular field should be serialized.
          (declaim (inline ,has-function-name))
          (defun ,has-function-name (,obj)
            ,(if index
                 `(= (bit (,is-set-accessor ,obj) ,index) 1)
                 `(let ((,cur-value ,(if bool-index
                                         `(plusp (bit (,bit-field-name ,obj) ,bool-index))
                                         `(,hidden-accessor-name ,obj))))
                    ,(case (proto-set-type field)
                       ((proto:byte-vector cl:string) `(not (= (length ,cur-value) 0)))
                       ((cl:double-float cl:float) `(not (= ,cur-value ,default-form)))
                       (t `(not (eq ,cur-value ,default-form)))))))
  
          ;; Clear function
          (declaim (inline ,clear-function-name))
  