anchor.diff:  (defconstant empty-rank (list 0 0 0 0 0 0 0 0))
   
   
  -(defmacro make-precomputed-table (name list)
  -  `(declaim (type (simple-array (unsigned-byte 64) (8)) ,name))
  +(defmacro make-precomputed-table (size name list)
  +  `(declaim (type (simple-array (unsigned-byte 64) (,size)) ,name))
     `(defconstant ,name
  -                (make-array 8 :element-type '(unsigned-byte 64)
  +                (make-array ,size :element-type '(unsigned-byte 64)
                               :initial-contents (mapcar #'make-bb ,list))))
   
  -
  -(defconstant clear-rank-list
  -  (let ((rank-list '()))
  -    (dotimes (rank 8)
  -      (let ((this-list (make-list 8 :initial-element full-rank)))
  -	(setf (nth rank this-list) empty-rank)
  -	(push this-list rank-list)))
  -    rank-list))
  -
  -(make-precomputed-table clear-rank clear-rank-list)
   
   (defun 1-at (n)
     (let ((line empty-rank))
  
positive.code: (defun make-bb-from-string (b)
    (declare (optimize speed (safety 0)) 
             (type string b))
  
negative.code: 
  
  
  (defconstant clear-rank-list
    (let ((rank-list '()))
      (dotimes (rank 8)
        (let ((this-list (make-list 8 :initial-element full-rank)))
  	(setf (nth rank this-list) empty-rank)
  	(push this-list rank-list)))
      rank-list))
  
  (make-precomputed-table 8 clear-rank clear-rank-list)
  
  
  (defconstant clear-file-list
              (mapcar #'transpose clear-rank-list))
  
  (make-precomputed-table 8 clear-file clear-file-list)
  
  (print clear-file-list)
  (print (mapcar #'make-bb clear-file-list))
  
  (defconstant mask-rank-list
               (mapcar #'inverse clear-rank-list))
  
  (make-precomputed-table 8 mask-rank mask-rank-list)
  
  (defconstant mask-file-list
               (mapcar #'transpose mask-rank-list))
  
  (make-precomputed-table 8 mask-file mask-file-list)
  
  (defun on-board (move-list)
    (remove-if (lambda (m) 
  		   (let ((i (car m)) (j (cadr m)))
  		     (or (> i 7) (< i 0)
  			 (> j 7) (< j 0))))
  		 move-list))
  
  (defun position-list-to-board-list (p)
    (let ((board))
      (loop for i from 0 to 7 do
  	 (let ((row))
  	   (loop for j from 0 to 7 do
  		(if (member (list i j) p :test #'equal)
  		    (push 1 row)
  		    (push 0 row)))
  	   (push row board)))
      (nreverse board)))
  
  (defun gen-move-list (func)
    (let ((moves))
      (loop for i from 0 to 7 do
  	 (loop for j from 0 to 7 do
  	      (push (funcall func i j) moves)))
      moves))
    
  
  (defun gen-king-moves (i j)
    (on-board  `((,(+ i 1) ,(+ j 1))
  	       (,(+ i 1) ,j)
  	       (,(+ i 1) ,(- j 1))
  	       (,(- i 1) ,(+ j 1))
  	       (,(- i 1) ,j)
  	       (,(- i 1) ,(- j 1))
  	       (,i ,(+ j 1))
  	       (,i ,(- j 1)))))
  
  (defconstant king-moves-list
    (gen-move-list #'gen-king-moves))
  
  (defun gen-knight-moves (i j)
    (on-board `((,(+ i 2) ,(+ j 1))
  	      (,(+ i 1) ,(+ j 2))
  	      (,(+ i 2) ,(- j 1))
  	      (,(+ i 1) ,(- j 2))
  	      (,(- i 2) ,(+ j 1))
  	      (,(- i 1) ,(+ j 2))
  	      (,(- i 2) ,(- j 1))
  	      (,(- i 1) ,(- j 2)))))
  
  (make-precomputed-table 
   64 king-positions (mapcar #'position-list-to-board-list king-moves-list))
  
  (print (mapcar #'position-list-to-board-list king-moves-list))
  (print (mapcar #'make-bb (mapcar #'position-list-to-board-list king-moves-list)))
  