anchor.diff:  (defun allocate-control-stack-slots (count)
     (when (oddp count) (incf count))
     (incf *control-stack-depth* count))
  +
  +(defun no-tail (value-mode)
  +  (ecase value-mode
  +    ((:multiple :predicate t nil) value-mode)
  +    (:tail :multiple)))
   
   (defun codegen-lambda (lambda)
     (let* ((*current-lambda* lambda)
  
positive.code:       (emit-label end-label)
        (setf *stack-values* (copy-stack-values stack-slots))
        (unless (zerop branch-count)
  	(setf *r8-value* (if (eql *for-value* :multiple)
                               :multiple
                               (list (gensym))))))))
  
  
negative.code:     ((null *for-value*)
       ;; Not for value
       (cg-progn form))
      (t (let ((tag (let ((*for-value* (case *for-value*
                                         (:predicate t)
                                         (:tail :multiple)
                                         (t *for-value*))))
                      (cg-form (second form)))))
           (smash-r8)
           (when (eql tag :multiple)
  