anchor.diff:      (defparameter trans-table (make-array 50))
       (defparameter index-trans-table 0))
     (let* ((ret-parse (parse-regex regex-string))
  -         (finish (get-ret 'end ret-parse)))
  -    (setf (state-attrib (access-state finish)) 'fi))
  +         (last-one (get-ret 'end ret-parse))
  +         (finish (add-state nil 'fi)))
  +    (setf (state-out1 (access-state last-one)) finish))
     (print-trans-table))
  +
  +(defmacro inspector (char)
  +  `(if (eq ,char current-char)
  +     (progn
  +       (format t "last-begin:~A~%" last-begin-index)
  +       (format t "last-end  :~A~%" last-end-index))))
   
   (defun parse-regex (regex-string &optional begin)
     "PARSE-REGEX
  
positive.code:       (let ((ret-parse (parse-regex paren-regex last-end-index)))
          (setf begin-index (get-ret 'begin ret-parse))
          (setf end-index   (get-ret 'end   ret-parse))
          (list begin-index end-index (+ 2 len))))))
  
  (defun make-union (union-string last-end-index)
    "MAKE-UNION
  
negative.code:    RETURN:(lst begin-index end-index length+2)
     "
    (let* ((current-char     nil)
           (begin-index      (if begin begin nil))
           (last-begin-index nil)
           (last-end-index   (if begin begin nil))
           (start?           (if begin nil t))
           (len (string-length regex-string)))
      (labels ((set-begin-end-f (begin end)
                 (if start?
                   (progn
                     (setf start? nil)
                     (setf begin-index begin)))
                 (setf last-begin-index begin)
                 (setf last-end-index end)))
        (dotimes (index (string-length regex-string))
          (setf current-char (get-char regex-string index))
          (inspector #\b)
          (cond ((eq #\( current-char)
                 (let* ((rest-exp (subseq regex-string index))
                        (paren-exp (get-first-paren rest-exp))
  