anchor.diff:  
   (defun write-term (term)
     (dereference term)
  -  (cond ((atom term)
  -         (princ (if (symbolp term) (constant-case term) term)))
  -	((variable-p term)
  +  (cond	((variable-p term)
            (princ (variable-case (variable-name term)))
            (princ "_")
            (princ (variable-level term)))
  +        ((atom term)
  +         (princ (if (symbolp term) (constant-case term) term)))
   	(t (write-functor-and-arguments (car term) (cdr term))))
     term)
   
  
positive.code:   (assert (symbolp x))
    (let ((y (gensym)))
      `(do nil (nil)
         (cond ((atom ,x)
  	      (return ,if-constant))
  	     ((variable-p ,x)
  	      (unless (let ((,y (variable-value ,x)))
  			(when ,y (setq ,x ,y)))
  		(return ,if-variable)))
  	     (t (return ,if-compound))))))
  
  (defvar *trail-array* (make-array 10000))
  
negative.code: ;;; Print execution time
  (defvar *print-execution-time* t)
  
  
  (defstruct (logic-variable (:conc-name variable-)
                             (:constructor new-variable (name level))
                             (:predicate variable-p))
    (level 0 :type (and (integer 0) fixnum))
    value
    name)
  
  (defmacro dereference (x &key (if-constant t)
                                (if-variable nil)
  