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:                (funcall operation
                          (%object-ref-unsigned-byte-32 x hi)
                          (%object-ref-unsigned-byte-32 y hi))))
      ;; 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))))
      result))
  
  (defun %%bignum-+ (x y)
  
negative.code:                                         (setf overflow (logtest (logand (logxor result a)
                                                                          (logxor result b))
                                                                 #x80000000))
                                          (setf carry (ldb (byte 1 32) result))
                                          (logand result #xFFFFFFFF))))))
      (let* ((sign (cond (overflow
                          ;; On overflow, extend the carry bit out and populate the last fragment with that.
  