anchor.diff:      (flet ((32bit (x) (logand #xffffffff x)))
         (declare (inline 32bit))
         (loop
  -         :with b0 :of-type (unsigned-byte 32) = (ref v 0)
  -         :with b1 :of-type (unsigned-byte 32) = (ref v 1)
  -         :with k :of-type (vector (unsigned-byte 32) 4) = (copy-seq k)
  -         :for i  :of-type fixnum :from 0 :below 16
  -         :for sk :of-type (unsigned-byte 32)
  -         = (32bit (+ (ref k 0) (ref k 1)
  -                     (logxor (+ (ref k 2) (ref k 3))
  -                             (32bit (ash (ref k 0)
  -                                         (mod (ref k 2) 32))))))
  -         :do
  -         (setf (ref k (mod i 4)) sk
  -               b0 (32bit (+ b0 (logxor (32bit (ash (+ sk b1) 9))
  -                                       (32bit (- sk b1))
  -                                       (32bit (ash (+ sk b1) -14)))))
  -               b1 (32bit (+ b1 (logxor (32bit (ash (+ sk b0) 9))
  -                                       (32bit (- sk b0))
  -                                       (32bit (ash (+ sk b0) -14))))))
  -
  -         :finally (setf (ref w 0) b0
  -                        (ref w 1) b1)))))
  +        :with b0 :of-type (unsigned-byte 32) = (ref v 0)
  +        :with b1 :of-type (unsigned-byte 32) = (ref v 1)
  +        :with k :of-type (vector (unsigned-byte 32) 4) = (copy-seq k)
  +        :for i  :of-type fixnum :from 0 :below 16
  +        :for sk :of-type (unsigned-byte 32)
  +        = (32bit (+ (ref k 0) (ref k 1)
  +                    (logxor (+ (ref k 2) (ref k 3))
  +                            (32bit (ash (ref k 0)
  +                                        (mod (ref k 2) 32))))))
  +        :do
  +        (setf (ref k (mod i 4)) sk
  +              b0 (32bit (+ b0 (logxor (32bit (ash (+ sk b1) 9))
  +                                      (32bit (- sk b1))
  +                                      (32bit (ash (+ sk b1) -14)))))
  +              b1 (32bit (+ b1 (logxor (32bit (ash (+ sk b0) 9))
  +                                      (32bit (- sk b0))
  +                                      (32bit (ash (+ sk b0) -14))))))
  +
  +        :finally (setf (ref w 0) b0
  +                       (ref w 1) b1)))))
   
   
   ;; void decode_raiden(unsigned long *data,unsigned long *result,unsigned
  
positive.code: ;;;;**************************************************************************
  
  (IN-PACKAGE "COMMON-LISP-USER")
  (DEFPACKAGE "COM.INFORMATIMAGO.COMMON-LISP.CESARUM.RAIDEN" (:USE "COMMON-LISP")
              (:EXPORT "RAIDEN-DECIPHER" "RAIDEN-ENCIPHER")
              (:DOCUMENTATION
               "This package imlements the RAIDEN block cipher.
      http://raiden-cipher.sourceforge.net/
  
      Copyright Pascal J. Bourguignon 2006 - 2006
  
negative.code: 
  (defun read-words (bits what)
    (loop
      :for bytes = (progn (format t "Please enter ~D bits of ~A: " 
                                  bits what)
                          (let ((buffer (read-line *standard-input* nil nil)))
                            (when buffer
                              (coerce (loop
                                        :for ch :in buffer
                                        :collect (char-code ch)) 'vector))))
      :while (and bytes (< (* 8 (length bytes)) bits))
      :finally (return
                 (and bytes
                      (loop for i from 0 by 4 below (truncate (+ 7 bits) 8)
                         collect (word (aref bytes (+ i 0))
  