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:    RETURN:(lst begin-index end-index length+2)
     "
    (let* ((current-char     nil)
           (initial-state    (if begin
                               begin
                               (add-state nil '∈)))
           (last-begin-index initial-state)
           (last-end-index   initial-state)
           (len (string-length regex-string)))
      (labels ((set-begin-end-f (begin end)
                 (setf last-begin-index begin)
                 (setf last-end-index end)))
        (dotimes (index (string-length regex-string))
          (setf current-char (get-char regex-string index))
          (cond ((eq #\( current-char)
                 (let* ((rest-exp (subseq regex-string index))
                        (paren-exp (get-first-paren rest-exp))
  
negative.code:                  (set-begin-end-f (get-ret 'begin ret-parse)
                                    (get-ret 'end   ret-parse))
                   (incf index (1- (get-ret 'len ret-parse)))))
                ((eq #\* current-char)
                 (let ((start (add-state nil '∈))
                       (end   (add-state nil '∈))
                       (paren-start (state-out1 (access-state last-begin-index)))
                       (paren-end   last-end-index))
                   (setf (state-out1 (access-state last-begin-index)) start)
                   (setf (state-out1 (access-state start)) paren-start)
                   (setf (state-out2 (access-state start)) end)
                   (setf (state-out1 (access-state paren-end)) end)
                   (setf (state-out2 (access-state paren-end)) paren-start)
                   ;(setf last-begin-index last-begin-index)
                   (setf last-end-index end)
                   ))
                (t ; Simple State
                 (let ((s-index (add-state current-char nil)))
                   (if start?
                     nil
                     (setf (state-out1 (access-state last-end-index)) s-index))
                   (set-begin-end-f s-index s-index)
                   ))
                ))
        (list begin-index last-end-index (+ 2 len)))))
  
  (defun get-ret (key parse-ret)
    "GET-RET
  