(defun parse-set-string (string)
  (prog ((stack '())
         (result '())
         (i 0)
         (length (length string))
         char)
   :start
     (when (= i length) (go :end))
   :pop-char
     (setf char (char string i))
     (cond ((char<= #\0 char #\9) (go :number-char))
           ((alpha-char-p char) (go :alpha-char))
           ((char= #\* char) (go :flip-last-number))
           (t (go :error)))
   :number-char
     (let ((rank (digit-char-p char)))
       (push (list rank nil) stack))
     (go :loop)
   :alpha-char
     (dolist (elt (nreverse stack))
       (destructuring-bind (number state) elt
         (let ((suit (a:rassoc-value *print-table* char
                                     :test #'char-equal)))
           (unless suit (go :error))
           (push (list number suit state) result))))
     (setf stack '())
     (go :loop)
   :flip-last-number
     (unless stack (go :error))
     (destructuring-bind (rank state) (pop stack)
       (let ((new-state (ecase state
                          ((nil) :flip)
                          (:flip :shouminkan))))
         (push (list rank new-state) stack)))
     (go :loop)
   :loop
     (incf i)
     (go :start)
   :end
     (return (nreverse result))
   :error
     (error 'riichi-evaluator-error)))