anchor.diff:  ;;; This way is kind of ugly, but I don't know a better way.
   (macrolet ((define-mode-function (&rest mode-definition-funs &environment env)
                (loop for fun in mode-definition-funs
  -                   collect (macroexpand `(,fun 16-byte-block-mixin nil 16) env) into forms
  -                   collect (macroexpand `(,fun 8-byte-block-mixin nil 8) env) into forms
  +                   collect (macroexpand `(,fun 16-byte-block-mixin 16) env) into forms
  +                   collect (macroexpand `(,fun 8-byte-block-mixin 8) env) into forms
                      finally (return `(progn ,@forms)))))
   
    
   ;;; ECB mode
   
  -(macrolet ((encrypt (cipher-specializer block-length-binding
  -                                                block-length-expr)
  +(macrolet ((encrypt (cipher-specializer block-length-expr)
                `(defmethod encrypt-with-mode ((cipher ,cipher-specializer)
                                               (mode ecb-mode) plaintext ciphertext
                                               plaintext-start plaintext-end
  
positive.code: 
  ;;; Padded modes
  
  (macrolet ((encrypt (cipher-specializer block-length-binding
                                          block-length-expr)
               `(defmethod encrypt-with-mode ((cipher ,cipher-specializer)
                                              (mode padded-cipher-mode)
                                              plaintext ciphertext
  
negative.code:                 (declare (type simple-octet-vector plaintext ciphertext))
                  (declare (type index ciphertext-start ciphertext-end plaintext-start))
                  (declare (ignorable handle-final-block))
                  (loop with iv of-type (simple-octet-vector ,(if (constantp `,block-length-expr)
                                                                  `,block-length-expr
                                                                  '*)) = (iv mode)
                        with iv-position of-type (integer 0 ,(if (constantp `,block-length-expr)
                                                                 `(,block-length-expr)
                                                                 '*)) = (iv-position mode)
                        with encrypt-function of-type function = (encrypt-function cipher)
                        for i of-type index from ciphertext-start below ciphertext-end
                        for j of-type index from plaintext-start
                        do (when (zerop iv-position)
                             (funcall encrypt-function cipher iv 0 iv 0))
                           (let ((b (logxor (aref ciphertext i) (aref iv iv-position))))
                             (setf (aref iv iv-position) (aref ciphertext i))
                             (setf (aref plaintext j) b)
                             (setf iv-position (mod (1+ iv-position) ,block-length-expr)))
                        finally (return-from decrypt-with-mode
                                  (let ((n-bytes-decrypted (- ciphertext-end ciphertext-start)))
                                    (setf (iv-position mode) iv-position)
                                    (values n-bytes-decrypted n-bytes-decrypted))))))
             (message-length (cipher-specializer block-length-expr)
               (declare (ignore block-length-expr))
               `(defmethod encrypted-message-length ((cipher ,cipher-specializer)
                                                     (mode cfb-mode) length
                                                     &optional handle-final-block)
  