anchor.diff:                                                 ,t))))))
               (emit end-label)
               (incf current-arg-index)))))
  -    (let* ((code-tag (let ((*for-value* :multiple))
  -                       (cg-form `(progn ,@(lambda-information-body lambda)))))
  -           (req-count (length (lambda-information-required-args lambda)))
  -           (opt-count (length (lambda-information-optional-args lambda)))
  -           (arg-count (+ req-count opt-count))
  -           (stack-arg-count (max 0 (- arg-count 5))))
  +    ;; ### Suppress TCE when binding special variables.
  +    (let* ((code-tag (let ((*for-value* (if *perform-tce* :tail :multiple)))
  +                       (cg-form `(progn ,@(lambda-information-body lambda))))))
         (when code-tag
           (unless (eql code-tag :multiple)
             (load-in-r8 code-tag t)
             (emit `(sys.lap-x86:mov32 :ecx ,(fixnum-to-raw 1))))
  -        (cond ((and (plusp stack-arg-count)
  -                    (zerop opt-count)
  -                    (not (lambda-information-rest-arg lambda)))
  -               ;; More than 5 required arguments, no &OPTIONAL or &REST.
  -               (emit `(sys.lap-x86:lea64 :rbx (:lfp ,(* stack-arg-count 8)))))
  -              ((or (and (plusp stack-arg-count)
  -                        (plusp opt-count))
  -                   (lambda-information-rest-arg lambda))
  -               ;; Many &OPTIONAL args or a &REST arg supplied. Do the full-fat pop.
  -               (emit `(sys.lap-x86:mov64 :rax (:cfp -24))
  -                     `(sys.lap-x86:xor32 :edx :edx)
  -                     `(sys.lap-x86:sub64 :rax ,(* 8 5))
  -                     `(sys.lap-x86:cmov64ng :rax :rdx)
  -                     `(sys.lap-x86:lea64 :rbx (:lfp :rax))))
  -              (t ;; 5 or fewer arguments, no &REST.
  -               (emit `(sys.lap-x86:mov64 :rbx :lfp))))
  -        (emit `(sys.lap-x86:mov64 :lfp (:cfp -8)))
  -        (emit `(sys.lap-x86:leave)
  -              `(sys.lap-x86:ret))))
  +        (emit-return-code)
  +        (emit `(sys.lap-x86:ret))))
       (sys.int::assemble-lap (nconc
   			    (generate-entry-code lambda)
   			    (nreverse *code-accum*)
   			    (apply #'nconc *trailers*))
                              *current-lambda-name*)))
  +
  +(defun emit-return-code (&optional tail-call)
  +  (let* ((req-count (length (lambda-information-required-args *current-lambda*)))
  +         (opt-count (length (lambda-information-optional-args *current-lambda*)))
  +         (arg-count (+ req-count opt-count))
  +         (stack-arg-count (max 0 (- arg-count 5))))
  +    (cond ((and (plusp stack-arg-count)
  +                (zerop opt-count)
  +                (not (lambda-information-rest-arg *current-lambda*)))
  +           ;; More than 5 required arguments, no &OPTIONAL or &REST.
  +           (emit `(sys.lap-x86:lea64 :rbx (:lfp ,(* stack-arg-count 8)))))
  +          ((or (and (plusp stack-arg-count)
  +                    (plusp opt-count))
  +               (lambda-information-rest-arg *current-lambda*))
  +           ;; Many &OPTIONAL args or a &REST arg supplied. Do the full-fat pop.
  +           (emit `(sys.lap-x86:mov64 :rax (:cfp -24))
  +                 `(sys.lap-x86:xor32 :edx :edx)
  +                 `(sys.lap-x86:sub64 :rax ,(* 8 5))
  +                 `(sys.lap-x86:cmov64ng :rax :rdx)
  +                 `(sys.lap-x86:lea64 :rbx (:lfp :rax))))
  +          (t ;; 5 or fewer arguments, no &REST.
  +           (emit `(sys.lap-x86:mov64 :rbx :lfp))))
  +    (emit `(sys.lap-x86:mov64 :lfp (:cfp -8)))
  +    (when tail-call
  +      (emit `(sys.lap-x86:mov64 :lsp :rbx)))
  +    (emit `(sys.lap-x86:leave))))
   
   (defun generate-entry-code (lambda)
     (let ((entry-label (gensym "ENTRY"))
  
positive.code:                (emit `(sys.lap-x86:mov64 ,(control-stack-slot-ea stack-pointer-save-area) :rbx))
                 (smash-r8)
                 (load-in-reg :r13 fn-tag t)
                 (let ((type-error-label (gensym))
                       (function-label (gensym)))
                   (emit-trailer (type-error-label)
  
negative.code: 	       (load-constant :r13 (first form))
  	       (smash-r8)
  	       (load-constant :rcx (length (rest form)))
                 (cond ((can-tail-call (rest form))
                        (emit-tail-call '(:symbol-function :r13) (first form))
                        nil)
                       (t (emit `(sys.lap-x86:call (:symbol-function :r13)))
                          (cond ((member *for-value* '(:multiple :tail))
                                 :multiple)
                                (t (emit `(sys.lap-x86:mov64 :lsp :rbx))
                                   (setf *r8-value* (list (gensym))))))))))))
  
  (defun can-tail-call (args)
    (and (eql *for-value* :tail)
         (null *special-bindings*)
         (<= (length args) 5)))
  
  (defun emit-tail-call (where &optional what)
    (format t "Performing tail call to ~S in ~S~%"
            what (lambda-information-name *current-lambda*))
    (emit-return-code t)
    (emit `(sys.lap-x86:jmp ,where)))
  
  ;;; Locate a variable in the environment.
  (defun find-var (var env chain)
  