anchor.diff:                                 y-sign-extension)))))
       result))
   
  -(defun %%bignum-+ (x y)
  +(defun %%bignum-+/- (x y op)
     (let* ((carry 0)
            (overflow nil)
            (size nil)
  
positive.code:                         carry)
                         (t
                          ;; Otherwise, sign-extend the second-last fragment out.
                          (ash (%object-ref-unsigned-byte-32 result (- size 3)) -31))))
             (sign-bits (if (eql sign 0)
                            #x00000000
                            #xFFFFFFFF)))
        (setf (%object-ref-unsigned-byte-32 result (- (* size 2) 2)) sign-bits
              (%object-ref-unsigned-byte-32 result (- (* size 2) 1)) sign-bits)
        (%%canonicalize-bignum result))))
  
  (defun %%bignum-- (x y)
    (let* ((carry 0)
           (overflow nil)
           (size nil)
           (result (operate-on-bignum x y
                                      (lambda (len-x len-y)
                                        (setf size (1+ (max len-x len-y))))
                                      (lambda (a b)
                                        (let ((result (- a (+ b carry))))
                                          (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.
                          carry)
                         (t
                          ;; Otherwise, sign-extend the second-last fragment out.
                          (ash (%object-ref-unsigned-byte-32 result (- size 3)) -31))))
             (sign-bits (if (eql sign 0)
                            #x00000000
                            #xFFFFFFFF)))
        (setf (%object-ref-unsigned-byte-32 result (- (* size 2) 2)) sign-bits
              (%object-ref-unsigned-byte-32 result (- (* size 2) 1)) sign-bits)
        (%%canonicalize-bignum result))))
  
  (defun %%bignum-logand (x y)
    (%%canonicalize-bignum
  
negative.code:                                     (lambda (len-x len-y)
                                        (setf size (1+ (max len-x len-y))))
                                      (lambda (a b)
                                        (let ((result (funcall op a b carry)))
                                          (setf overflow (logtest (logand (logxor result a)
                                                                          (logxor result b))
                                                                 #x80000000))
  