anchor.diff:  ;;;;**************************************************************************
   
   (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.
  +(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
  
positive.code:     (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)))))
  
  
  ;; void decode_raiden(unsigned long *data,unsigned long *result,unsigned
  
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))
  