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:    parse a regex-string recursively.
     RETURN:(lst begin-index end-index length+2)
     "
    (let ((current-char nil)
          (begin-index nil)
          (end-index nil)
          (len (string-length regex-string)))
      (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-regex (subseq regex-string index))
                      (ret-parse  (deal-with-paren
                                    (get-first-paren rest-regex))))
                 )
              (t (progn
                   ; Simple State
                   (let ((s-index (add-state current-char nil)))
                     (cond ((= 0 index) (setf begin-index s-index))
                           ((= (1- len)) (setf end-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
  
negative.code:   (progn
      (defparameter trans-table (make-array 50))
      (defparameter index-trans-table 0))
    (setf regex-string
          (concatenate 'string regex-string "♂"))
    (parse-regex regex-string))
  
  (defun parse-regex (regex-string)
  