Нерекурсивная реализация функции Аккермана

Тут возник вопрос как вычислить функцию Аккермана. Проблема в том, что непосредственная рекурсивная реализация данной функции очень активно потребляет стэк и вычислить её для каких-нибудь чуть более интересных числе (например m=3, n=15) не получается, так как CLisp или даже SBCL потребляют весь стэк и дело заканчивается плачевно. Рецепт лечения очевиден: необходимо переписать функцию без использования рекурсии. Что-то меня в этой задаче зацепило и я это родил (особо впечатлительным не смотреть):

 (defvar *akk-cache* nil)

(defun akk (x y)
  (let ((*akk-cache* (or *akk-cache*
                         (make-hash-table :test 'equal)))
        (stack `((,x ,y))))
    (flet ((akk-cache (m n)
             (gethash `(,m ,n) *akk-cache*))
           (new-value (value)
             (setf (gethash (car stack) *akk-cache*)
                   value)
             (cond
               ((not stack) t)
               ((not (second stack))
                (pop stack))
               ((second (second stack))
                (pop stack))
               (t (let ((m (first (car stack)))
                        (n (second (car stack)))
                        (i (first (second stack))))
                    (pop stack)
                    (pop stack)
                    (push (list i (gethash `(,m ,n) *akk-cache*))
                          stack))))))
      (loop
         while stack
         do (let ((m (first (car stack)))
                  (n (second (car stack))))
              (if (akk-cache m n)
                  (pop stack)
                  (cond ((= m 0)
                         (new-value (1+ n)))
                        ((and (= n 0)
                              (akk-cache (1- m) 1))
                         (new-value (akk-cache (1- m) 1)))
                        ((= n 0)
                         (push (list (1- m) 1)
                               stack))
                        ((and (akk-cache m (1- n))
                              (akk-cache (1- m)
                                         (akk-cache m (1- n))))
                         (new-value (akk-cache (1- m)
                                               (akk-cache m (1- n)))))
                        ((akk-cache m (1- n))
                         (push (list (1- m)
                                     (akk-cache m (1- n)))
                               stack))
                        (t (push (list (1- m))
                                 stack)
                           (push (list m (1- n))
                                 stack))))))
      (akk-cache x y)))) 

Выглядит страшновато, но работает :)