anchor.diff: +(defconstant table64 '(63 0 58 1 59 47 53 2
  +                       60 39 48 27 54 33 42 3
  +      	               61 51 37 40 49 18 28 20
  +                       55 30 34 11 43 14 22 4
  +                       62 57 46 52 38 26 32 41
  +                       50 36 17 19 29 10 13 21
  +                       56 45 25 31 35 16 9 12
  +                       44 24 15  8 23 7 6 5))
  +(defconstant index64 (make-array 64 :element-type '(unsigned-byte 16)
  +                                :initial-contents table64))
  +(defconstant debruijn64 #x07EDD5E59A4E28C2)
  +
  +(defun bitscan (bb)
  +  (declare (optimize speed)
  +	   (type (unsigned-byte 64) bb))
  +  (let ((ashbb (ash (ldb (byte 64 0)
  +			 (* (logand bb (- (lognot bb) 1))
  +			    debruijn64))
  +		    -58)))
  +    (aref index64 ashbb)))
  +
   (defun make-bb-from-string (b)
     (declare (optimize speed (safety 0)) 
              (type string b))
  
positive.code: 
  
  
  ;(declaim (type (simple-array (unsigned-byte 64) (8)) clear-rank))
  ;(defconstant clear-rank 
  ;             (make-array 8 :element-type '(unsigned-byte 64)
  ;                         :initial-contents (mapcar #'make-bb clear-rank-list)))
  (defconstant clear-file-list
              (mapcar #'transpose clear-rank-list))
  
  (make-precomputed-table clear-file clear-file-list)
  
  (defconstant mask-rank-list
               (mapcar #'inverse clear-rank-list))
  
  (make-precomputed-table mask-rank mask-rank-list)
  
  (defconstant mask-file-list
               (mapcar #'transpose mask-rank-list))
  
  (make-precomputed-table mask-file mask-file-list)
  
  (defconstant diagonal-ones-list
    (loop
       for i from 0 below 8
         collect (1-at i)))
  
  (defun padlist (l)
    (if (< (length l) 8)
        (padlist (cons empty-rank l)) l))
  
  (defconstant upper-left-diagonals-list
    (loop
       for i from 0 below 8
         collect (reverse (padlist 
  			 (reverse (nthcdr i diagonal-ones-list))))))
  
  (princ upper-left-diagonals-list)
  
  (make-precomputed-table upper-left-diagonals 
  			upper-left-diagonals-list)
  
  (defconstant lower-right-diagonals-list
    (reverse (mapcar #'reverse upper-left-diagonals-list)))
  
  (make-precomputed-table lower-right-diagonals
  			lower-right-diagonals-list)
  
  (defconstant upper-right-diagonals-list
    (reverse (mapcar #'reverse (mapcar #'reverse upper-left-diagonals-list))))
  
  
  (make-precomputed-table upper-right-diagonals
  			upper-right-diagonals-list)
  
  (defconstant lower-left-diagonals-list
    (reverse (mapcar (lambda (l) (reverse (mapcar #'reverse l))) 
  		   upper-left-diagonals-list)))
  
  
  (make-precomputed-table lower-left-diagonals
  			lower-left-diagonals-list)
  
  
  
negative.code: (defconstant empty-rank (list 0 0 0 0 0 0 0 0))
  
  
  (defmacro make-precomputed-table (size name list)
    `(declaim (type (simple-array (unsigned-byte 64) (,size)) ,name))
    `(defconstant ,name
                  (make-array ,size :element-type '(unsigned-byte 64)
                              :initial-contents (mapcar #'make-bb ,list))))
  
  
  (defun 1-at (n)
    (let ((line empty-rank))
  