anchor.diff:        (emit-closure-slot-set out (first regs) (car varrec-ref) (second regs)))
       (emit-convert-value out (first regs) dest in-frame-base out-frame-base)))
   
  -(define-reg-use (call attrs . args)
  +(define-reg-use ((call tail-call varargs-tail-call) attrs . args)
     (reg-use-recurse form dest-type-value)
     general-register-count)
   
  
positive.code: (define-propogate (begin attrs . body)
    (propogate-recurse-last (car body) (cdr body) operator))
  
  (define-propogate (call attrs . args)
    (if (eq? 'return (first operator))
        (begin
          (overwrite-form form (list* 'tail-call (append (second operator) attrs)
                                      args))
          (simplify form))
        (propogate-recurse form operator)))
  
  ;;; We currently conflate character and numbers.  So eliminate
  ;;; character-related operators:
  
negative.code:     (emit-call out (and (eq? 'ref (first func)) (second func)))
      (emit-restore-%func out)
      (emit-convert-value out %funcres dest in-frame-base out-frame-base)))
  
  (define-codegen (tail-call attrs func . args)
    (let* ((new-frame-base in-frame-base))
  