anchor.diff:      out-vec))
   
   (defun find-pos (row col)
  +  (declare (type fixnum row col))
     (+ (* row *board-length*) col)) 
   
   (defun find-row-col (pos)
  +  (declare (type fixnum pos))
     (let ((col  (mod pos *board-length*))
           (row (floor (/ pos *board-length*)))
           )
  
positive.code:               (< 3 (length (gg-board-history game))))
         ;; Check for for infringement of the Ko rule
         (unless (dolist (move valid-moves)
                   ;; When a group was captured
                   (if (and (< 1 (length (gg-move-history game))) 
                            (svref (first (gg-move-history game)) 1))
                     ;; Check that the board is not returning to 
                     ;; the state prior to your opponents last
                     ;; move. (Ko Rule)
  
                     ;; Playing with fire
                     (let ((new-board nil)
                           (old-board nil))
                       ;; Mod Game
                       (do-move! game move)
                       ;; Get board
                       (setq new-board (gg-board game))
                       ;; Unmod game 
                       (undo-move! game)
  
                       ;; Get the old board
                       (setq old-board (first (gg-board-history game)))
  
                       (unless (equal-board? new-board old-board)
                         (push move legal-moves)))
                     (push move legal-moves)))
           ;; Return legal moves
           legal-moves)
  
  
negative.code: 
              (dolist (group connected-groups)
                (setf (svref (gg-groups game) player)
                      (remove group 
                              (svref (gg-groups game) 
                                     player)
                              :test #'equal-group?)))
  