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:                    ;; not a list
                     form )) )))
      ;; do parse local-function
      (multiple-value-bind (lambda-list init-params) (separate-pairs bindings)
        (let ((gs-lambda-list
                (mapcar (lambda (x) (gensym (symbol-name x))) lambda-list))
              (gs (mapcar (lambda (x) (gensym (symbol-name x))) lambda-list))
              (exit-val  (gensym "EXIT-VALUE-"))
              (block-tag (gensym "BLOCK-TAG-"))
              (start-tag (gensym "START-TAG-"))
              (nr-fn     (gensym "NO-RETURN-FN-")) )
          (multiple-value-bind (doc decls body) (separate-declarations body)
            ;; make customized macrolets
            `(macrolet ((no-return ((,nr-fn ,@gs))
                          "to be translated into GO expr with update"
                          (unless (eq ,nr-fn ',name)
                            (error
  
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)
  