anchor.diff:  			 ((and (type= available-type '(boolean))
   			       (type= type '(integer)))
   			  (return-from pop-form
  -			    (values `(if ,lisp-form 1 0))))
  +			    (values `(if ,lisp-form 1 0) '(boolean) side-effects-p)))
   			 ((null-type effective-type)
   			  (bst-compile-error "Type mismatch: expecting ~A, got ~A."
   					     type available-type))
  
positive.code: 
  ;;; Packaging the computed data
  
  (defun max-side-effects (a b)
    "Compute the maximum of the side-effects A and B."
    (case a
      ((nil) b)
      (:assignment :assignment)
      (t (if (eql b :assignment) :assignment a))))
  
  (defun package-as-body ()
    "Build a Lisp body corresponding to the computation captured in
  
negative.code: but try to beautify the result by using COND rather than IF in certain cases."
    (let ((then-operator (and (consp then-form) (car then-form)))
  	(else-operator (and (consp else-form) (car else-form))))
      (cond
        ((equal then-form '(values)) ;; we have, in fact, an `unless'
         `(unless ,val-form
  	 ,@(if (eql else-operator 'progn)
  	       (cdr else-form)
  	       (list else-form))))
        ((equal else-form '(values)) ;; we have, in fact, a `when'
         `(when ,val-form
  	 ,@(if (eql then-operator 'progn)
  	       (cdr then-form)
  	       (list then-form))))
        ((or (eql then-operator 'progn)
  	   (member else-operator '(if progn cond)))
         ;; beautify the condition using `cond'
         `(cond
  	 (,val-form ,@(if (eql then-operator 'progn)
  			  (cdr then-form)
  			  (list then-form)))
  	 ,@(case else-operator
  		 (progn `((t ,@(cdr else-form))))
  		 (if `((,(cadr else-form)
  			,(caddr else-form))
  		       (t
  			,(cadddr else-form))))
  		 (cond (cdr else-form))
  		 (t `((t ,else-form))))))
        (t 
         ;; normal if
         `(if ,val-form
  	 ,then-form
  	 ,else-form)))))  
  
  (defun bst-compile-literal (literal stack &key (borrowing-allowed t))
    "Compile a BST function LITERAL , which is a symbol, designating a
  