anchor.diff:    (multiple-value-bind (efun dfun) (mode-crypt-functions cipher mode)
       (setf (slot-value mode 'encrypt-function) efun
             (slot-value mode 'decrypt-function) dfun)))
  -
  -#+nil
  -(defmethod initialize-instance :after ((mode padded-cipher-mode)
  -                                       &key buffer-length)
  -  (setf (slot-value mode 'buffer)
  -        (make-array buffer-length :element-type '(unsigned-byte 8))))
   
   (defvar *supported-modes* (list :ecb :cbc :ofb :cfb :cfb8 :ctr))
   
  
positive.code:              (type (mod #.most-positive-fixnum) carry))
      (setf (aref block i) (logand sub #xff)))
    (values))
  
  ;;; Only really works on big-endian processors...
  #+nil
  (defun increment-counter-block (block)
    (let ((words (truncate (length block) sb-vm:n-word-bytes))
          (carry 1))
      (loop for i from (1- words) downto 0
            until (zerop carry) do
            (let ((word (sb-kernel:%vector-raw-bits block i)))
              (multiple-value-setq (word carry)
                (sb-bignum:%add-with-carry word 0 carry))
              (setf (sb-kernel:%vector-raw-bits block i) word)))
      (values)))
  
  ;;; This way is kind of ugly, but I don't know a better way.
  (macrolet ((define-mode-function (&rest mode-definition-funs &environment env)
  
negative.code:                 length)))
    (define-mode-function mode-crypt message-length))
  
  (defmethod mode-crypt-functions (cipher (mode stream-mode))
    (flet ((stream-crypt-function (function)
             (declare (type function function))
  