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:                  (setf (%object-ref-unsigned-byte-32 new (* i 2))
                         (%object-ref-unsigned-byte-32 bignum (* i 2)))
                   (setf (%object-ref-unsigned-byte-32 new (1+ (* i 2)))
                         (%object-ref-unsigned-byte-32 bignum (1+ (* i 2)))))))))))
  
  (defun operate-on-bignum (x y length-fn operation)
    (let* ((len-x (%n-bignum-fragments x))
           (len-y (%n-bignum-fragments y))
           (result (%make-bignum-of-length (funcall length-fn len-x len-y))))
      ;; Make sure that Y is at least as large as X.
      (when (> len-x len-y)
        (rotatef x y)
        (rotatef len-x len-y))
      ;; Fragments are 64-bits wide, but the compiler will generate more bignums
      ;; trying to read a full 64-bit fragment. Operate on 32-bit pairs instead.
      (loop
         for i below len-x
         for lo from 0 by 2
         for hi = (1+ lo)
         do
  
negative.code:     (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 (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)
  