anchor.diff:              (svref evals *white*))
       (format str "Current Val: ~A, Whose Turn ~A, Game Over? ~A~%" 
               (eval-func game)
  -            whose-turn?
  +            player
               (game-over? game)))
     (when verbose?
       (format str "~%Black Groups:~%~A" (svref (gg-groups game) *black*)) 
  
positive.code: (defconstant *black* 0)
  (defconstant *white* 1)
  (defconstant *group-dist* 4)
  (defconstant *board-length* 6)
  (defconstant *board-size* (* *board-length* *board-length*)) 
  
  (defun cl (filename)
  
negative.code:             ;; Increment the capture flag
              (setq captured (+ 1 captured))
              ;; Capture the group
              (capture-group! group game player))
            (when (= 1 (length (group-pieces group)))
              (setf (gg-ko? game) t)))
  
          ;; Check if the move would kill the current group
          (unless (check-group? (gg-board game) 
                                (first (svref (gg-groups game) player)))
  
            (capture-group! (first (svref (gg-groups game) (- 1 player)))
                            game player)
  
          (when (= captured 0)
            (setf (gg-ko? game) nil))
          ;; Evaluate each players score
          (eval-subtotals! game)
  
          (push (vector pos captured) (gg-move-history game)))))
  
      ;; Chenge turn
      (setf (gg-whose-turn? game) (- 1 player))))
  