anchor.diff:                 (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))))
  +    ;; 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)
  
positive.code:            (sign-bits (if (eql sign 0)
                            #x00000000
                            #xFFFFFFFF)))
        (setf (%object-ref-unsigned-byte-32 result (- size 2)) sign-bits
              (%object-ref-unsigned-byte-32 result (- size 1)) sign-bits)
        (%%canonicalize-bignum result))))
  
  (defun %%bignum-logand (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.
  