anchor.diff:  ;}}}
   
   (progn
  -  (defparameter trans-table (make-array 50))
  +  (defparameter trans-table (make-array 100))
     (defparameter index-trans-table 0))
  +
  +(array-dimension trans-table 0)
  +
  +(defun print-trans-table ()
  +  (dotimes (index (array-dimension trans-table 0))
  +    (if (eq 0 (aref trans-table index))
  +      (return))
  +    (format t "~A: ~A~%" index (aref trans-table index))))
   
   (defstruct (state (:print-function print-state))
     (attrib nil)
  
positive.code:    RETURN: numbers"
    (cond ((eq 'begin key) (nth 0 parse-ret))
          ((eq 'end   key) (nth 1 parse-ret))
          ((eq 'lenth key) (nth 2 parse-ret))))
  
  (defun deal-with-paren (paren-regex)
    "DEAL-WITH-PAREN
  
negative.code:    parse a regex-string recursively.
     RETURN:(lst begin-index end-index length+2)
     "
    (let ((current-char     nil)
          (begin-index      nil)
          (end-index        nil)
          (last-begin-index nil)
          (last-end-index   nil)
          (begin?           t)
          (len (string-length regex-string)))
      (labels ((set-begin-end-f (begin end)
                 (if begin?
                   (progn (setf begin? nil)
                          (setf begin-index begin)))
                 (setf last-begin-index begin)
                 (setf end-index end)
                 (setf last-end-index end)))
        (dotimes (index (string-length regex-string))
          (setf current-char (get-char regex-string index))
          (cond ((eq #\♂ current-char)
                 (progn
                   (add-state nil 'finish)
                   (return)))
                ((eq #\( current-char)
                 (let* ((rest-exp (subseq regex-string index))
                        (paren-exp (get-first-paren rest-exp))
                        (parse-ret nil))
                   (if (is-union paren-exp)
                     (if (not (union-ugly-p paren-exp))
                       ()))
                   (set-begin-end-f (get-ret 'begin parse-ret)
                                    (get-ret 'end   parse-ret))
                   (incf index (1- (get-ret 'len parse-ret)))))
                (t (progn
                     ; Simple State
                     (let ((s-index (add-state current-char nil)))
                       (set-begin-end-f s-index s-index)
                       (setf (state-out1 (aref trans-table s-index))
                             (1+ s-index)))))
                ))
        (list begin-index end-index (+ 2 len)))))
  
  (defun get-ret (key parse-ret)
    "GET-RET
  