anchor.diff:          (let ((ret-parse (make-union 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)))
  +          (list last-end-index end-index (+ 2 len)))
           (error "deal-with-paren: ugly union!"))
         ; simple paren
         (let ((ret-parse (parse-regex paren-regex last-end-index)))
  
positive.code:                (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))
                        (ret-parse
                          (deal-with-paren paren-exp last-end-index)))
                   (set-begin-end-f (get-ret 'begin ret-parse)
                                    (get-ret 'end   ret-parse))
                   (incf index (1- (get-ret 'len ret-parse)))))
  
negative.code:                  (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-end-index end)
                   ))
                (t ; Simple State, algorithm: ♂
                 (if start?
                   (progn
                     (setf start? nil)
                     (let ((new-s (add-state current-char nil)))
                       (setf begin-index new-s)
                       (set-begin-end-f new-s new-s)))
                   (if (and (null (state-match (access-state last-end-index)))
                            (null (state-attrib (access-state last-end-index))))
                     (progn
                       (setf (state-match (access-state last-end-index))
                             current-char)
                       (set-begin-end-f last-end-index last-end-index))
                     (let ((new-s (add-state current-char nil)))
                       (setf (state-out1 (access-state last-end-index)) new-s)
                       (set-begin-end-f new-s new-s))))
                 )))
        (list begin-index last-end-index (+ 2 len)))))
  
  (defun get-ret (key parse-ret)
  