anchor.diff:       (svref (gg-subtotals game) (- 1(gg-whose-turn? game)))))
   
   
  -(defun find-group (pos player game)
  -  (let ((groups (svref (gg-groups game) player)))
  -    (dolist (group groups)
  -      (when (find pos (group-pieces group))
  -        (return-from find-group (group-territory group))))))
  -
  -
  -
  -;;  PRINT-GO
  +(defun find-group (pos game)
  +  (let ((piece (svref (gg-board game) pos)))
  +    (if (< 0 piece)
  +        (let* ((player (- piece 1)) 
  +              (groups (svref (gg-groups game) player)))
  +          (dolist (group groups)
  +            (when (find pos (group-pieces group))
  +              (return-from find-group 
  +                           (group-territory group)))))
  +    '-)))
  +
  +    ;;  PRINT-GO
   ;; ----------------------------
   ;;  Print function for the GO-GAME struct
   (defun print-go (game str depth &optional (verbose? nil))
     (declare (ignore depth))
     (let ((board (gg-board game))
           (evals (gg-subtotals game))
  -        (whose-turn? (gg-whose-turn? game)))
  +        (player (gg-whose-turn? game)))
       (format str "~% ===== TURN[~A] =====~%" (length (gg-move-history game)))
       (format str "   0 1 2 3 4 5 6 7 8~%")
       (format str "  -------------------~%")
       (dotimes (row *board-length*)
         (format str "~A  " row)
         (dotimes (col *board-length*)
  -        (let ((p (svref board (find-pos col row))))
  -          (cond 
  -            ((= 0 p) (format str "- "))
  -            ((= 1 p) (format str " "))
  -            ((= 2 p) (format str "o ")))))
  +        (let* ((pos (svref board (find-pos col row)))
  +               (p (find-group (find-pos col row) game)))
  +          ;(cond 
  +           ; ((= 0 p) (format str "- "))
  +            ;((= 1 p) (format str " "))
  +            ;((= 2 p) (format str "o ")))))
  +            (format str "~A " p)))
         (format str "~%"))
       (format str "  -------------------~%")
       (format str "             Black    White  ~%")
  
positive.code:       ;; Otherwise return false
        nil)))
  
  ;;  CAPTURE-GROUP! : GROUP GAME
  ;; ---------------------------------
  ;;  INPUTS
  ;;  SIDE-EFFECT: Destructively modify the game state by 
  ;;          capturing GROUP
  (defun capture-group! (group game)
    ;;(format t "Capture group: ~A ~%" group)
    (let ((opponent (- 1 (gg-whose-turn? game))))
      ;; Remove the groups from the opponent's groups
      (setf (svref (gg-groups game) opponent) 
            (delete group (svref (gg-groups game) opponent)))
  
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))))
  