anchor.diff:                   (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 nil '∈)))
  -                 (setf (state-out1 (access-state last-end-index))
  -                       s-index)
  -                 (setf (state-attrib (access-state last-end-index))
  -                       nil)
  -                 (setf (state-match (access-state last-end-index))
  -                       current-char)
  -                 (set-begin-end-f last-end-index s-index)
  +               (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 initial-state last-end-index (+ 2 len)))))
  +      (list begin-index last-end-index (+ 2 len)))))
   
   (defun get-ret (key parse-ret)
     "GET-RET
  
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))
  