anchor.diff:               ;; expand local-function
                ;; global block for a LOCAL-FUNCTION expr
                (block ,block-tag  ; for global exit from a local function
  -               (labels ((,name ,gs-lambda-list
  +               (labels ((,name ,(mapcar #'second lambda-list-info)
                             ;; allocate declarations and a documentation
  -                          (declare ,@(replace-decls
  -                                       decls lambda-list gs-lambda-list ))
  +                          (declare ,@(replace-decls decls lambda-list-info))
                             ,@doc
                             ;; allocate function body
                             (tagbody
                               ,start-tag  ; for no-return and tail recursion
  -                            (let ,(mapcar (lambda (var val) `(,var ,val))
  -                                          lambda-list gs-lambda-list )
  +                            (let ,(mapcar (lambda (lst) (subseq lst 0 2))
  +                                          lambda-list-info )
                                 (declare ,@(mapcan #'identity decls))
                                 (return-from ,name
                                   (progn
                                     ,@(butlast body)
                                     ,(eliminate-tail-recursion
  -                                     start-tag lambda-list
  +                                     start-tag (mapcar #'car lambda-list-info)
                                        (car (last body)) )))) )))
                    ;; for debug
                    ,@(when *local-function-verbose-debug*
                        `((disassemble #',name) (terpri)) )
                    ;; execute local function
  -                 (,name ,@init-params) ))))))))
  -
  +                 (,name ,@(mapcar #'fourth lambda-list-info)) ))) ))))
  +
  
positive.code:                      end
                       finally (return (values acc-doc acc-decl acc-form)) )))
             ;;
             (replace-all (src from-elms to-elms)
               ;; assume (= (length from-elms) (length to-elms))
               (loop for from-elm in from-elms
                     for to-elm in to-elms
                     for list = (subst to-elm from-elm src)
                         then   (subst to-elm from-elm list)
                     finally (return list) ))
             ;;
             (decl-filter (decl lambda-list gs-lambda-list)
               (case (car decl)
                 (type ; (type typespec var*)
                   (list* (first decl) (second decl)
                          (replace-all (cddr decl)
                                       lambda-list gs-lambda-list )))
                 ((inline notinline ftype optimize)
                  ;; none of arguments of local-function affected
                  (copy-list decl) )
  
negative.code:                 ;; ({ignore|ignorable} {var|(function fn)}*)
                   (warn "LOCAL-FUNCTION implement limitation: IGNORE and IGNORABLE are not supported correctly on this version: ~s~%" decl)
                  (cons (car decl)
                        (replace-all (cdr decl) lambda-list-info) ))
                 (otherwise
                  ;; (dynamic-extent {var|(function fn)}*)
                  ;; or (special var*)
                  ;; or (typespec var*)
                  (cons (car decl)
                        (replace-all (cdr decl) lambda-list-info) ))))
             ;;
             (replace-decls (decls-list lambda-list-info)
                 ;; decls-list is a list of lists
                 ;; s.t. (((type fixnum i) (ignore x)) ((optimize ...)))
                 (loop for decls in decls-list
                       append (loop for decl in decls
                                    collect (decl-filter
                                              decl lambda-list-info ))))
             ;;
             (eliminate-tail-recursion (start-tag lambda-list tail-form)
               ;; leave form as it is when force-elimination not required
  