anchor.diff:                   (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)
  -                 ))
  -              ))
  +              (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)
  
positive.code:   "MAKE-UNION
     make union states.
     RETURN:(lst begin-index end-index length+2)"
    (let* ((begin-index last-end-index)
           (end-index   (add-state nil '∈))
           (len         (string-length union-string))
           (split-cons (split-union union-string))
           (regex1 (car split-cons))
           (regex2 (cdr split-cons)))
      (let* ((ret-parse    (parse-regex regex1))
             (begin1-index (get-ret 'begin ret-parse))
             (end1-index   (get-ret 'end   ret-parse)))
        (setf (state-out1 (access-state begin-index)) begin1-index)
        (setf (state-out1 (access-state end1-index)) end-index))
      (let* ((ret-parse    (parse-regex regex2))
             (begin2-index (get-ret 'begin ret-parse))
             (end2-index   (get-ret 'end   ret-parse)))
        (setf (state-out2 (access-state begin-index)) begin2-index)
        (setf (state-out1 (access-state end2-index)) end-index))
      (list last-end-index end-index (+ 2 len))))
  
  
  (defun get-first-paren (regex-string)
    "GET-FIRST-PAREN
  
negative.code:         (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 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)))
  