anchor.diff:        )
         (setf *play-so-far* (snoc move *play-so-far*))
         (if (game-over-p *play-so-far*) (return nil))
  +   )
  +   *play-so-far*
  +)
  +
  +(defmethod generic-play-with-stats ((x player) (o player) (report t) &aux move)
  +   (setf *avail* '(nw n ne w c e sw s se))
  +   (setf *play-so-far* ())
  +   (dolist (player '(x o x o x o x o x))
  +      (visualize *play-so-far*)
  +      (cond
  +         ((eq player 'x)
  +            (setf move (make-move x report))
  +         )
  +         ((eq player 'o)
  +            (setf move (make-move o report))
  +         )
  +      )
  +      (setf *play-so-far* (snoc move *play-so-far*))
  +      (if (game-over-p *play-so-far) return nil)
  +   )
  +   (cond
  +      ((eq (analyze *play-so-far* 'w)
  +         (cond
  +            ((eq *most-recent-hmp-move 'random)
  +               (setf *nr-random-moves-wins-by-hmp* (+ 1 *nr-random-moves-wins-by-hmp*))
  +            )
  +            ((eq *most-recent-hmp-move 'heuristic)
  +               (setf *nr-heristic-move-wins-by-hmp* (+ 1 *nr-heristic-move-wins-by-hmp*))
  +            )
  +         )
  +      )
      )
      *play-so-far*
   )
  
positive.code:    (format t "~A~%" (analyze p))
     nil
  )
  
negative.code: ; a human player
  (defclass human-player (player) ())
  
  ; heuristic machine player class
  (defclass heuristic-machine-player (player)
     (
        (rules :accessor heuristic-machine-player-rules :initform ())
     )
  )
  ; textual display of a random machine player
  (defmethod display ((p random-machine-player))
     (format t "RANDOM MACHINE PLAYER ...~%")
     (format t "name = ~A~%" (player-name p))
     (format t "~%")
     nil
  )
  ; textual display of a human player
  (defmethod display ((p human-player))
     (format t "HUMAN PLAYER ...~%")
     (format t "name = ~A~%" (player-name p))
     (format t "~%")
     nil
  )
  ; textual display of a human player
  (defmethod display ((p heuristic-machine-player))
     (format t "HEURISTIC MACHINE PLAYER ...~%")
     (format t "name = ~A~%" (player-name p))
     (format t "number of rules = ~A~%" (length (heuristic-machine-player-rules p)))
     (format t "rules ... ~%")
     (dolist (rule (heuristic-machine-player-rules p))
        (print-rule rule) (terpri)
     )
     (format t "~%")
     nil
  )
  
  (defmethod make-rule ( (l list) )
     (setf if-part (list 'prefix 'of l 'matches 'the 'play 'so 'far))
     (setf then-part (list 'select 'move 'from l))
     (list 'if if-if-part 'then then-part)
  )
  
  (defmethod add-rule ((p heuristic-machine-player) (l list))
     (setf
        (heuristic-machine-player-rules p)
        (append (heuristic-machine-player-rules p) (list (make-rule l)))
     )
     nil
  )
  
  (defmethod add-rules ((p heuristic-machine-player) (n integer))
     (dotimes (i n) (add-rule p (winning-play)))
     nil
  )
  
  (defmethod print-rule ((rule list))
     (format t "~A " (first rule))
     (format t "~A~%" (second rule))
     (format t "~A " (third rule))
     (format t "~A~%" (forth rule))
     nil
  )
  
  (defmethod winning-play (&aux p)
     (setf p (play))
     (cond
        ((eq (analyze p) 'w)
           p
        )
        (t
           (winning-play))
     )
  )
  
  ; move making method for machine
  