anchor.diff:                       end
                        finally (return (values acc-doc acc-decl acc-form)) )))
              ;;
  -           (replace-all (src from-elms to-elms)
  +           (replace-all (src lambda-list-info)
                ;; 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)
  +             (loop for (from to) in lambda-list-info
  +                   for list = (subst to from src)
  +                       then   (subst to from list)
                      finally (return list) ))
              ;;
  -           (decl-filter (decl lambda-list gs-lambda-list)
  +           (decl-filter (decl lambda-list-info)
                (case (car decl)
                  (type ; (type typespec var*)
                    (list* (first decl) (second decl)
  -                        (replace-all (cddr decl)
  -                                     lambda-list gs-lambda-list )))
  +                        (replace-all (cddr decl) lambda-list-info) ))
                  ((inline notinline ftype optimize)
                   ;; none of arguments of local-function affected
                   (copy-list decl) )
  
positive.code:              ;; 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
                            ;; allocate declarations and a documentation
                            (declare ,@(replace-decls
                                         decls lambda-list gs-lambda-list ))
                            ,@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 )
                                (declare ,@(mapcan #'identity decls))
                                (return-from ,name
                                  (progn
                                    ,@(butlast body)
                                    ,(eliminate-tail-recursion
                                       start-tag lambda-list
                                       (car (last body)) )))) )))
                   ;; for debug
                   ,@(when *local-function-verbose-debug*
                       `((disassemble #',name) (terpri)) )
                   ;; execute local function
                   (,name ,@init-params) ))))))))
  
  
negative.code:                    for (var val) = (if (valid-binding-p elm)
                                       (if (symbolp elm) (list elm) elm)
                                       (error "invalid binding form: ~a" elm) )
                     collect (list var
                                   (gensym (symbol-name var))
                                   (gensym (concatenate 'string
                                             (symbol-name var) "-UPDATE") )
                                   val )))
             ;;
             (declare-p (form)
               (and (consp form)
  