anchor.diff:     (format t "~A~%" (analyze p))
      nil
   )
  +; a heuristic machine player and a human play one game
  +(defmethod demo-heuristic-human ((nr-rules integer) &aux p x o)
  +   (setf *nr-random-moves-by-hmp* 0)
  +   (setf *nr-heuristic-moves-by-hmp* 0)
  +   (setf *nr-random-moves-wins-by-hmp* 0)
  +   (setf *nr-heuristic-moves-wins-by-hmp* 0)
  +   (setf x (make-instance 'heuristic-machine-player :name 'hm))
  +   (add-rules x nr-rules)
  +   (display x)
  +   (setf o (make-instance 'human-player :name 'hu))
  +   (display o)
  +   (setf p (generic-play-with-stats x o t))
  +   (format t "Game Summary~%")
  +   (format t "Play of the game = ~A~%" p)
  +   (visualize p)
  +   (format t "~A~%" (analyze p))
  +   (format t "heuristic use summary~%")
  +   (summarize-heuristic-use)
  +   nil
  +)
  +; a heuristic machine player and a random machine player play one game
  +(defmethod demo-heuristic-random ((nr-rules integer) &aux p x o)
  +   (setf *nr-random-moves-by-hmp* 0)
  +   (setf *nr-heuristic-moves-by-hmp* 0)
  +   (setf *nr-random-moves-wins-by-hmp* 0)
  +   (setf *nr-heuristic-moves-wins-by-hmp* 0)
  +   (setf x (make-instance 'heuristic-machine-player :name 'hm))
  +   (add-rules x nr-rules)
  +   (display x)
  +   (setf o (make-instance 'random-machine-player :name 'rm))
  +   (display o)
  +   (setf p (generic-play-with-stats x o t))
  +   (format t "Game Summary~%")
  +   (format t "Play of the game = ~A~%" p)
  +   (visualize p)
  +   (format t "~A~%" (analyze p))
  +   (format t "heuristic use summary~%")
  +   (summarize-heuristic-use)
  +   nil
  +)
  
positive.code:       )
        (setf *play-so-far* (snoc move *play-so-far*))
        (if (game-over-p *play-so-far*) (return nil))
     )
     *play-so-far*
  )
  
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
  