anchor.diff:  #-SYMBOLICS
   (eval-when (eval compile load)
     (defmacro stack-let (bindings &body body)
  -    ;; stack-let on the 3600 is like let except variable values are consed on the stack, not in the heap
  -    ;; thereby diminishing allocation/deallocation costs
  +    ;; stack-let on the 3600 is like let except variable values are
  +    ;; consed on the stack, not in the heap thereby diminishing
  +    ;; allocation/deallocation costs
       `(let ,bindings . ,body)))
   
   #+SYMBOLICS
  
positive.code: 	 (do ((x (cadr args) (caddr x)))
  	     (nil)
  	   (dereference x)
  	   (cond ((eq x '|[]|) (princ "]") (return))
  		 ((and (not (atom x)) (eq (car x) 'cons/2)) (princ ",") (write-term (cadr x)))
  		 (t (princ "|") (write-term x) (princ "]") (return)))))
  	((and *writing* (setq spec (specifier fn)))
  	 (setq prec (precedence fn))
  	 (case spec
  	   ((fx fy)
  	    (princ (function-case (functor-name fn)))
  	    (princ " ")
  	    (cond ((parenthesize-argument (car args) prec (if (eq spec 'fx) #'<= #'<))
  		   (princ "(") (write-term (car args)) (princ ")"))
  		  (t (write-term (car args)))))
  	   ((xf yf)
  	    (cond ((parenthesize-argument (car args) prec (if (eq spec 'fx) #'<= #'<))
  		   (princ "(") (write-term (car args)) (princ ")"))
  		  (t (write-term (car args))))
  	    (princ " ")
  	    (princ (function-case (functor-name fn))))
  	   ((xfx xfy yfx yfy)
  	    (cond ((parenthesize-argument (car args) prec (if (member spec '(xfx xfy)) #'<= #'<))
  		   (princ "(") (write-term (car args)) (princ ")"))
  		  (t (write-term (car args))))
  	    (princ " ")
  	    (princ (function-case (functor-name fn)))
  	    (princ " ")
  	    (cond ((parenthesize-argument (cadr args) prec (if (member spec '(xfx yfx)) #'<= #'<))
  		   (princ "(") (write-term (cadr args)) (princ ")"))
  		  (t (write-term (cadr args)))))))
  	(t (princ (function-case (functor-name fn)))
  
negative.code:   (write-functor-and-arguments fn args))
  
  (defun write-clause (clause &optional number variables)
    (let ((goalp (and (eq (car clause) '<-/2)
                      (equal (cadr clause) '(query/0)))))
      (fresh-line)
      (when goalp (princ " ----------------") (terpri))
      (when number
        (if (consp number)
            (format t "~3D~A. " (car number) (cdr number))
            (format t "~3D.  " number)))
      (if goalp
          (let (quantified)
            (write-term (cadr clause))
            (princ " <- ")
            (dolist (v variables)
              (when (variable-occurs-in-term-p v (caddr clause))
                (princ "(") (write-term v) (princ ")") (setq quantified t)))
            (when quantified (princ " "))
            (write-term (caddr clause)))
          (let (quantified)
            (dolist (v variables)
              (when (variable-occurs-in-term-p v clause)
                (princ "(") (write-term v) (princ ")") (setq quantified t)))
            (when quantified (princ " "))
            (write-term clause)))
      (princ ".")))
  
  
  (defvar *tracing* nil)
  (defvar *spy-points* nil)
  