;; 256bit(key)+1(const) x 4224(132*32) matrix, last column for constant subterms
(defvar *matrix* (make-array '(257 4224) :element-type '(mod 1)))
 
;; All of the 256 key-bits, from a0 .. h31
(defvar *keybits* (append (reverse *a*) (reverse *b*)
                          (reverse *c*) (reverse *d*)
                          (reverse *e*) (reverse *f*)
                          (reverse *g*) (reverse *h*)))
 
(defun key-bit-pos (keybit)
  "Find the position of a given key bit token in the 256-bit key."
  (position keybit *keybits*))
 
;; Form the matrix.
(loop for k from 0 upto 131 do
     (let ((terms (serpent-recurrence k))) ;; current w-term
       (loop for w-bit from 0 upto (1- +bitness+) do
            ;; current bit of w-term
            (let* ((w-row (+ (* k +bitness+) w-bit))
                   (term (nth (1- (- +bitness+ w-bit)) terms))
                   ;; the constant term
                   (const (if (equal (second term) 1)
                              1
                              0))
                   ;; the free variables
                   (clause (if (zerop const)
                               (cdr term)
                               (cddr term))))
              ;; save the free variables into the matrix
              (loop for var in clause do
                   (setf (aref *matrix*
                               (key-bit-pos var)
                               w-row)
                         1))
              ;; save the constant term into last column of matrix
              (setf (aref *matrix*
                          256
                          w-row)
                    const)))))
 
;; let's have it as bitmap:
(with-open-file (stream "serpent.pbm"
                        :direction :output
                        :if-exists :overwrite
                        :if-does-not-exist :create)
  (format stream "P1~%#serpent~%~A ~A~%" 257 4224)
  (loop for wb from 0 to 4223 do
       (loop for kb from 0 to 256 do
            (format stream "~A " (aref *matrix* kb wb)))
       (format stream "~%")))
 
(quit)