anchor.diff:      (let ((sbit (bignum-sign-32 bignum)))
         ;; Now loop, until there are either no more redundant sign-extension fragments or until the length is zero.
         (loop
  -         (when (zerop len)
  -           (return))
            (when (not (and (eql (%object-ref-unsigned-byte-32 bignum (- (* len 2) 1)) sbit)
                            (eql (%object-ref-unsigned-byte-32 bignum (- (* len 2) 2)) sbit)))
  +           (return))
  +         (when (not (zerop (logand #x80000000
  +                                   (logxor (%object-ref-unsigned-byte-32 bignum (- (* len 2) 3))
  +                                           sbit))))
  +           (return))
  +         (when (eql len 1)
              (return))
            (decf len))
         (cond ((eql len 0)
  
positive.code:                                         (setf overflow (logtest (logand (logxor result a)
                                                                          (logxor result b))
                                                                 #x80000000))
                                          (setf carry (ash result -32))
                                          (logand result #xFFFFFFFF))))))
      (let* ((sign (cond (overflow
                          ;; On overflow, extend the carry bit out and populate the last fragment with that.
  
negative.code:                (funcall operation
                          (%object-ref-unsigned-byte-32 x hi)
                          (%object-ref-unsigned-byte-32 y hi))))
      ;; Preserve operand order!
      (cond ((< len-x len-y)
             ;; Deal with the length mismatch, sign extending X to match Y.
             (loop
                with x-sign-extension = (bignum-sign-32 x)
                for i below (- len-y len-x)
                for lo from (* len-x 2) by 2
                for hi = (1+ lo)
                do
                  (setf (%object-ref-unsigned-byte-32 result lo)
                        (funcall operation
                                 x-sign-extension
                                 (%object-ref-unsigned-byte-32 y lo)))
                  (setf (%object-ref-unsigned-byte-32 result hi)
                        (funcall operation
                                 x-sign-extension
                                 (%object-ref-unsigned-byte-32 y hi)))))
            ((< len-y len-x)
             ;; Deal with the length mismatch, sign extending Y to match X.
             (loop
                with y-sign-extension = (bignum-sign-32 y)
                for i below (- len-x len-y)
                for lo from (* len-y 2) by 2
                for hi = (1+ lo)
                do
                  (setf (%object-ref-unsigned-byte-32 result lo)
                        (funcall operation
                                 (%object-ref-unsigned-byte-32 x lo)
                                 y-sign-extension))
                  (setf (%object-ref-unsigned-byte-32 result hi)
                        (funcall operation
                                 (%object-ref-unsigned-byte-32 x hi)
                                 y-sign-extension)))))
      result))
  
  (defun %%bignum-+ (x y)
  