diff --git a/contrib/walker/example.lisp b/contrib/walker/example.lisp
index 145e69a..171dd62 100644
--- a/contrib/walker/example.lisp
+++ b/contrib/walker/example.lisp
@@ -134,3 +134,46 @@
 
 (loop :with ((x y) . z) := (f)
       :with a := (+ x y z))
+
+(loop :for x :in '(1 2 3) :do (print x))
+(loop :with foo
+      :for x :in '(1 2 3) :do (print x))
+(loop :with foo := nil
+      :for x :in '(1 2 3) :do (print x))
+(loop :with fn := #'cddr :and a
+      :for x :in (list a) :by fn :do (print x))
+
+(loop :for x :on '(1 2 3) :do (print x))
+(loop :with foo
+      :for x :on '(1 2 3) :do (print x))
+(loop :with foo := nil
+      :for x :on '(1 2 3) :do (print x))
+(loop :with fn := #'cddr :and a
+      :for x :on (list a) :by fn :do (print x))
+(loop :for x := 1
+      :do (f x))
+(loop :for x := 1 :then (f x)
+      :do (f x))
+(loop :for (x . y) := (f)
+      :do (f x y))
+
+(loop for k being each hash-key in (plist-hash-table '((:a) 1 (:b) 2))
+      do (print k))
+
+(let ((v 0))
+  (loop for k being each hash-key in (plist-hash-table '((:a) 1 (:b) 2))
+        using (hash-value v)
+        do (print (cons k v)))
+  v)
+
+(loop for v being the hash-value in *ht*
+      do (print v))
+(loop for v being each hash-values of *ht* using (hash-key k)
+      do (format t "~a=>~a~%" k v))
+
+(loop :for name :being :each :external-symbol
+      :do (print name))
+
+(let ((package-name (f)))
+  (loop :for name :being :each :external-symbol :in package-name
+        :do (print name)))
diff --git a/contrib/walker/loop-form.lisp b/contrib/walker/loop-form.lisp
index c6d30c5..4a4fef2 100644
--- a/contrib/walker/loop-form.lisp
+++ b/contrib/walker/loop-form.lisp
@@ -18,6 +18,8 @@
    (fianl-clauses :initarg :final-clauses
                   :type (proper-list final-clause)
                   :reader loop-form-final-clauses)
+   (for-as-clauses :initarg :for-as-clauses
+                   :reader loop-form-for-as-clauses)
    (doing-forms :initarg :doing-forms
                 :type (proper-list ast)
                 :reader loop-form-doing-forms)
@@ -49,6 +51,43 @@
 (defclass it-form (ast)
   ())
 
+(defclass <for-as-in-on-list-clause> (ast)
+  ((d-vars :initarg :d-vars
+           :reader ast-d-vars)
+   (in-on :initarg :in-on
+          :reader ast-in-on)
+   (by :initarg :by
+       :reader ast-by)))
+
+(defclass for-as-in-list-clause (<for-as-in-on-list-clause>) ())
+(defclass for-as-on-list-clause (<for-as-in-on-list-clause>) ())
+
+(defclass for-as-equals-then-clause (ast)
+  ((d-vars :initarg :d-vars
+            :reader ast-d-vars)
+   (equals :initarg :equals
+           :reader ast-equals)
+   (then :initarg :then
+         :reader ast-then)))
+
+(defclass for-as-across-clause (ast)
+  ((d-vars :initarg :d-vars
+           :reader ast-d-vars)
+   (across :initarg :across
+           :reader ast-across)))
+
+(defclass for-as-hash-clause (ast)
+  ((d-vars :initarg :d-vars
+           :reader ast-d-vars)
+   (hash-table :initarg :hash-table
+               :reader ast-hash-table)))
+
+(defclass for-as-package-clause (ast)
+  ((d-vars :initarg :d-vars
+           :reader ast-d-vars)
+   (package :initarg :package
+            :reader ast-package)))
+
 (defun walk-d-var-spec (walker d-var-spec env path)
   (cond ((null d-var-spec)
          '())
@@ -74,12 +113,13 @@
 
 (defmethod walk-complex-loop-form ((walker walker) form env path)
   (assert (and (proper-list-p form) (eq 'loop (first form))))
-  (let ((pos 0)
+  (let ((pos 1)
         (exps (rest form))
         (named-binding nil)
         (with-clauses '())
         (initial-clauses '())
         (final-clauses '())
+        (for-as-clauses '())
         (doing-forms '())
         (return-forms '()))
     (labels ((lookahead ()
@@ -88,16 +128,18 @@
                (walker-assert (not (null exps)))
                (incf pos)
                (pop exps))
-             (accept (name)
-               (when (and (typep (lookahead) '(or symbol string))
-                          (string= name (lookahead)))
+             (match (names)
+               (when (symbolp (lookahead))
+                 (loop :for name :in names
+                       :thereis (string= name (lookahead)))))
+             (accept (&rest names)
+               (when (match names)
                  (next)
                  t))
-             (exact-var ()
-               (let ((var (next)))
-                 (assert-type var 'variable-symbol)
-                 var))
-
+             (exact (&rest names)
+               (walker-assert (match names))
+               (next)
+               t)
              (d-var-spec (path)
                (let ((d-var-spec (next)))
                  (walk-d-var-spec walker d-var-spec env path)))
@@ -118,19 +160,20 @@
              (with-clause ()
                (when (accept :with)
                  (let ((clauses
-                           (loop :for d-vars := (d-var-spec (cons (1+ pos) path))
-                                 :do (type-spec)
-                                 :collect (make-instance
-                                           'with-clause
-                                           :path nil ; TODO
-                                           :d-vars d-vars
-                                           :value (when (accept :=)
-                                                    (let ((value (walk walker
-                                                                       (next)
-                                                                       env
-                                                                       (cons pos path))))
-                                                      value)))
-                                 :while (accept :and))))
+                         (loop :for d-vars := (d-var-spec (cons pos path))
+                               :do (type-spec)
+                               :collect (make-instance
+                                         'with-clause
+                                         :path nil ; TODO
+                                         :d-vars d-vars
+                                         :value (when (accept :=)
+                                                  (let* ((pos pos)
+                                                         (value (walk walker
+                                                                      (next)
+                                                                      env
+                                                                      (cons pos path))))
+                                                    value)))
+                               :while (accept :and))))
                    (setf env
                          (extend-env* env
                                       (mapcan (lambda (clause)
@@ -142,8 +185,7 @@
                    (accumulation)
                    (conditional)
                    (termination-test)
-                   (initial-final)
-                   ))
+                   (initial-final)))
              (main-clause* ()
                (loop :while (main-clause)))
              (initial-final ()
@@ -154,16 +196,16 @@
                       (push (make-instance 'final-clause :forms (compound-forms))
                             final-clauses))))
              (unconditional ()
-               (cond ((or (accept :do)
-                          (accept :doing))
+               (cond ((accept :do :doing)
                       (setf doing-forms (append doing-forms (compound-forms))))
                      ((accept :return)
-                      (if (accept :it)
-                          (push (make-instance 'it-form :path (cons pos path))
-                                return-forms)
-                          (let ((form (next)))
-                            (push (walk walker form env (cons pos path))
-                                  return-forms))))))
+                      (let ((pos pos))
+                        (if (accept :it)
+                            (push (make-instance 'it-form :path (cons pos path))
+                                  return-forms)
+                            (let ((form (next)))
+                              (push (walk walker form env (cons pos path))
+                                    return-forms)))))))
              (accumulation ()
                ;; TODO
                )
@@ -174,26 +216,107 @@
                ;; TODO
                )
              (for-as-clause ()
-               (loop :while (or (accept :for) (accept :as))
+               (loop :while (accept :for :as)
                      :collect (for-as-subclause)))
              (for-as-subclause ()
-               (let ((var (exact-var)))
+               (let ((for-pos (1- pos))
+                     (d-vars (d-var-spec (cons pos path))))
                  (type-spec)
-                 (let ((binding (make-instance 'lexical-variable-binding :name var)))
-                   (declare (ignore binding))
-                   (cond ((accept :in)
-                          )
-                         ((accept :on)
-                          )
-                         ((accept :=)
-                          )
-                         ((accept :across)
-                          )
-                         ((accept :being)
-                          )
-                         (t
-                          ;; TODO: error
-                          )))))
+                 (cond ((accept :in)
+                        (for-as-in-list for-pos d-vars))
+                       ((accept :on)
+                        (for-as-on-list for-pos d-vars))
+                       ((accept :=)
+                        (for-as-equals-then for-pos d-vars))
+                       ((accept :across)
+                        (for-as-across for-pos d-vars))
+                       ((accept :being)
+                        (setf d-vars (for-as-being for-pos d-vars)))
+                       (t
+                        ;; TODO: error
+                        ;; TODO: from, to, downfrom, downto, above, by
+                        ))
+                 (setf env (extend-env* env (mapcar #'ast-binding d-vars)))))
+
+             (for-as-in-on-list (ast-class for-pos d-vars)
+               (let* ((in (walk walker (next) env (cons (+ for-pos 3) path)))
+                      (by (when (accept :by)
+                            (walk walker (next) env (cons (+ for-pos 5) path)))))
+                 (push (make-instance ast-class
+                                      :path (cons for-pos path)
+                                      :d-vars d-vars
+                                      :in-on in
+                                      :by by)
+                       for-as-clauses)))
+             (for-as-in-list (for-pos d-vars)
+               (for-as-in-on-list 'for-as-in-list-clause for-pos d-vars))
+             (for-as-on-list (for-pos d-vars)
+               (for-as-in-on-list 'for-as-on-list-clause for-pos d-vars))
+             (for-as-equals-then (for-pos d-vars)
+               (let* ((env (extend-env* env (mapcar #'ast-binding d-vars)))
+                      (in (walk walker (next) env (cons (+ for-pos 3) path)))
+                      (by (when (accept :then)
+                            (walk walker (next) env (cons (+ for-pos 5) path)))))
+                 (push (make-instance 'for-as-equals-then-clause
+                                      :path (cons for-pos path)
+                                      :d-vars d-vars
+                                      :equals in
+                                      :then by)
+                       for-as-clauses)))
+             (for-as-across (for-pos d-vars)
+               (let ((across (walk walker (next) env (cons (+ for-pos 3) path))))
+                 (push (make-instance 'for-as-across-clause
+                                      :path (cons for-pos path)
+                                      :d-vars d-vars
+                                      :across across)
+                       for-as-clauses)))
+
+             (for-as-being-hash (for-pos d-vars other-var-keyword)
+               (let* ((hash-table-pos pos)
+                      (hash-table (walk walker (next) env (cons hash-table-pos path))))
+                 (when (accept :using)
+                   (let ((using-pos pos)
+                         (using (next)))
+                     (with-walker-bindings (hash-value other-var) using
+                       (walker-assert (and (symbolp hash-value)
+                                           (string= hash-value other-var-keyword)))
+                       (assert-type other-var 'variable-symbol)
+                       (push (make-instance
+                              'd-var
+                              :binding (make-instance 'lexical-variable-binding
+                                                      :name other-var)
+                              :path (list* 1 using-pos path))
+                             d-vars))))
+                 (push (make-instance 'for-as-hash-clause
+                                      :path (cons for-pos path)
+                                      :d-vars d-vars
+                                      :hash-table hash-table)
+                       for-as-clauses))
+               d-vars)
+             (for-as-package (for-pos d-vars)
+               (push (make-instance 'for-as-package-clause
+                                    :path (cons for-pos path)
+                                    :d-vars d-vars
+                                    :package (when (accept :in :of)
+                                               (let ((package-pos pos))
+                                                 (walk walker
+                                                       (next)
+                                                       env
+                                                       (cons package-pos path)))))
+                     for-as-clauses))
+             (for-as-being (for-pos d-vars)
+               (exact :each :the)
+               (cond ((accept :hash-key :hash-keys)
+                      (exact :in :of)
+                      (for-as-being-hash for-pos d-vars :hash-value))
+                     ((accept :hash-value :hash-values)
+                      (exact :in :of)
+                      (for-as-being-hash for-pos d-vars :hash-key))
+                     (t
+                      (exact :symbol :symbols :present-symbol :present-symbols
+                             :external-symbol :external-symbols)
+                      (for-as-package for-pos d-vars)
+                      d-vars)))
              (type-spec ()
                (cond ((member (lookahead) '(t nil fixnum float))
                       (next)
@@ -204,7 +327,8 @@
                      (t
                       nil)))
              (compound-forms ()
-               (let ((exp (next)))
+               (let ((pos pos)
+                     (exp (next)))
                  (walker-assert (consp exp))
                  (cons (walk walker exp env (cons pos path))
                        (loop :for exp := (lookahead)
@@ -219,6 +343,7 @@
                      :with-clauses (nreverse with-clauses)
                      :initial-clauses (nreverse initial-clauses)
                      :final-clauses (nreverse final-clauses)
+                     :for-as-clauses (nreverse for-as-clauses)
                      :doing-forms (nreverse doing-forms)
                      :return-forms (nreverse return-forms)))))
 
@@ -238,12 +363,14 @@
   (visit-foreach visitor (loop-form-with-clauses ast))
   (visit-foreach visitor (loop-form-initial-clauses ast))
   (visit-foreach visitor (loop-form-final-clauses ast))
+  (visit-foreach visitor (loop-form-for-as-clauses ast))
   (visit-foreach visitor (loop-form-doing-forms ast))
   (visit-foreach visitor (loop-form-return-forms ast)))
 
 (defmethod visit (visitor (ast with-clause))
   (visit-foreach visitor (ast-d-vars ast))
-  (visit visitor (ast-value ast)))
+  (when (ast-value ast)
+    (visit visitor (ast-value ast))))
 
 (defmethod visit (visitor (ast initial-clause))
   (visit-foreach visitor (ast-forms ast)))
@@ -254,5 +381,28 @@
 (defmethod visit (visitor (ast it-form))
   nil)
 
+(defmethod visit (visitor (ast <for-as-in-on-list-clause>))
+  (visit-foreach visitor (ast-d-vars ast))
+  (visit visitor (ast-in-on ast))
+  (when (ast-by ast) (visit visitor (ast-by ast))))
+
+(defmethod visit (visitor (ast for-as-equals-then-clause))
+  (visit-foreach visitor (ast-d-vars ast))
+  (visit visitor (ast-equals ast))
+  (when (ast-then ast) (visit visitor (ast-then ast))))
+
+(defmethod visit (visitor (ast for-as-across-clause))
+  (visit-foreach visitor (ast-d-vars ast))
+  (visit visitor (ast-across ast)))
+
+(defmethod visit (visitor (ast for-as-hash-clause))
+  (visit-foreach visitor (ast-d-vars ast))
+  (visit visitor (ast-hash-table ast)))
+
+(defmethod visit (visitor (ast for-as-package-clause))
+  (visit-foreach visitor (ast-d-vars ast))
+  (when (ast-package ast)
+    (visit visitor (ast-package ast))))
+
 (defmethod visit (visitor (ast simple-loop-form))
   (visit visitor (ast-body ast)))
diff --git a/contrib/walker/tests/test-cases.lisp b/contrib/walker/tests/test-cases.lisp
new file mode 100644
index 0000000..c62566c
--- /dev/null
+++ b/contrib/walker/tests/test-cases.lisp
@@ -0,0 +1,2200 @@
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (BLOCK FOO
+    (RETURN-FROM FOO 10)
+    (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
+    (RETURN-FROM FOO 40))
+  (1))
+ ((1 4) (1 2) (1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS FOO NIL) NIL)
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS FOO NIL) NIL)
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS FOO NIL) NIL)
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (BLOCK FOO
+    (RETURN-FROM FOO 10)
+    (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
+    (RETURN-FROM FOO 40))
+  (1))
+ ((1 4) (1 2) (1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (BLOCK FOO
+    (RETURN-FROM FOO 10)
+    (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
+    (RETURN-FROM FOO 40))
+  (1 2))
+ ((1 4) (1 2) (1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (BLOCK FOO
+    (RETURN-FROM FOO 10)
+    (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
+    (RETURN-FROM FOO 40))
+  (1 3))
+ ((1 3 3) (1 2 3) (1 3)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (BLOCK FOO
+    (RETURN-FROM FOO 10)
+    (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
+    (RETURN-FROM FOO 40))
+  (1 2 3))
+ ((1 3 3) (1 2 3) (1 3)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (BLOCK FOO
+    (RETURN-FROM FOO 10)
+    (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
+    (RETURN-FROM FOO 40))
+  (1 3 3))
+ ((1 3 3) (1 2 3) (1 3)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (BLOCK FOO
+    (RETURN-FROM FOO 10)
+    (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
+    (RETURN-FROM FOO 40))
+  (1 4))
+ ((1 4) (1 2) (1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET* ((A 0) (B A))
+    (LET* ((A A) (B A))
+      A)
+    A)
+  (0 0 1))
+ ((3) (1 0 1 2) (1 1 1) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET* ((A 0) (B A))
+    (LET* ((A A) (B A))
+      A)
+    A)
+  (0 1 1))
+ ((0 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET* ((A 0) (B A))
+    (LET* ((A A) (B A))
+      A)
+    A)
+  (1 1 1))
+ ((3) (1 0 1 2) (1 1 1) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET* ((A 0) (B A))
+    (LET* ((A A) (B A))
+      A)
+    A)
+  (0 0 1 2))
+ ((2 2) (1 1 1 2) (0 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET* ((A 0) (B A))
+    (LET* ((A A) (B A))
+      A)
+    A)
+  (1 0 1 2))
+ ((3) (1 0 1 2) (1 1 1) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET* ((A 0) (B A))
+    (LET* ((A A) (B A))
+      A)
+    A)
+  (0 1 1 2))
+ ((0 1 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET* ((A 0) (B A))
+    (LET* ((A A) (B A))
+      A)
+    A)
+  (1 1 1 2))
+ ((2 2) (1 1 1 2) (0 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET* ((A 0) (B A))
+    (LET* ((A A) (B A))
+      A)
+    A)
+  (2 2))
+ ((2 2) (1 1 1 2) (0 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET* ((A 0) (B A))
+    (LET* ((A A) (B A))
+      A)
+    A)
+  (3))
+ ((3) (1 0 1 2) (1 1 1) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 1))
+    (LET ((B A))
+      A
+      B))
+  (0 0 1))
+ ((2 2) (1 0 1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 1))
+    (LET ((B A))
+      A
+      B))
+  (0 0 1 2))
+ ((3 2) (0 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 1))
+    (LET ((B A))
+      A
+      B))
+  (1 0 1 2))
+ ((2 2) (1 0 1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 1))
+    (LET ((B A))
+      A
+      B))
+  (2 2))
+ ((2 2) (1 0 1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 1))
+    (LET ((B A))
+      A
+      B))
+  (3 2))
+ ((3 2) (0 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (0 0 1))
+ ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (0 1 1))
+ ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (1 2))
+ ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (2 2))
+ ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (2 2))
+ ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (2 3))
+ ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (3 3))
+ ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (4 3))
+ ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (1 4))
+ ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (2 4))
+ ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (3 4))
+ ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (4 4))
+ ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (1 5))
+ ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (2 5))
+ ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (1 6))
+ ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (2 6))
+ ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (3 6))
+ ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (1 7))
+ ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (2 2 7))
+ ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (3 7))
+ ((3 7)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (0 1))
+ ((2) (1 5 1) (0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (1 1))
+ ((1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (2 1))
+ ((2 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (3 1))
+ ((3 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (0 5 1))
+ ((3) (0 5 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (1 5 1))
+ ((2) (1 5 1) (0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (6 1))
+ ((4) (6 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (0 8 1))
+ ((5) (0 8 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (2))
+ ((2) (1 5 1) (0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (3))
+ ((3) (0 5 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (4))
+ ((4) (6 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (5))
+ ((5) (0 8 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
+                                        (0 1 1))
+ ((2 1) (1 5 1 1) (0 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
+                                        (1 1 1))
+ ((1 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
+                                        (2 1 1))
+ ((2 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
+                                        (3 1 1))
+ ((3 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
+                                        (0 5 1 1))
+ ((3 1) (0 5 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
+                                        (1 5 1 1))
+ ((2 1) (1 5 1 1) (0 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
+                                        (6 1 1))
+ ((4 1) (6 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
+                                        (0 8 1 1))
+ ((5 1) (0 8 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (2 1))
+ ((2 1) (1 5 1 1) (0 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (3 1))
+ ((3 1) (0 5 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (4 1))
+ ((4 1) (6 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (5 1))
+ ((5 1) (0 8 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (FLET ((F ()
+           ))
+    (FLET ((F (&OPTIONAL (X 1))
+             X
+             #'F
+             (F X)))
+      (F X)
+      #'F))
+  (0 0 1))
+ ((0 4 0 1 2) (3 0 1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (FLET ((F ()
+           ))
+    (FLET ((F (&OPTIONAL (X 1))
+             X
+             #'F
+             (F X)))
+      (F X)
+      #'F))
+  (1 1 2))
+ NIL)
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (FLET ((F ()
+           ))
+    (FLET ((F (&OPTIONAL (X 1))
+             X
+             #'F
+             (F X)))
+      (F X)
+      #'F))
+  (0 0 1 2))
+ ((3 2) (0 2 2) (0 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (FLET ((F ()
+           ))
+    (FLET ((F (&OPTIONAL (X 1))
+             X
+             #'F
+             (F X)))
+      (F X)
+      #'F))
+  (0 1 1 0 1 2))
+ ((1 4 0 1 2) (2 0 1 2) (0 1 1 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (FLET ((F ()
+           ))
+    (FLET ((F (&OPTIONAL (X 1))
+             X
+             #'F
+             (F X)))
+      (F X)
+      #'F))
+  (2 0 1 2))
+ ((1 4 0 1 2) (2 0 1 2) (0 1 1 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (FLET ((F ()
+           ))
+    (FLET ((F (&OPTIONAL (X 1))
+             X
+             #'F
+             (F X)))
+      (F X)
+      #'F))
+  (4 0 1 2))
+ NIL)
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (FLET ((F ()
+           ))
+    (FLET ((F (&OPTIONAL (X 1))
+             X
+             #'F
+             (F X)))
+      (F X)
+      #'F))
+  (3 0 1 2))
+ ((0 4 0 1 2) (3 0 1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (FLET ((F ()
+           ))
+    (FLET ((F (&OPTIONAL (X 1))
+             X
+             #'F
+             (F X)))
+      (F X)
+      #'F))
+  (0 4 0 1 2))
+ ((0 4 0 1 2) (3 0 1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (FLET ((F ()
+           ))
+    (FLET ((F (&OPTIONAL (X 1))
+             X
+             #'F
+             (F X)))
+      (F X)
+      #'F))
+  (1 4 0 1 2))
+ ((1 4 0 1 2) (2 0 1 2) (0 1 1 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (FLET ((F ()
+           ))
+    (FLET ((F (&OPTIONAL (X 1))
+             X
+             #'F
+             (F X)))
+      (F X)
+      #'F))
+  (0 2 2))
+ ((3 2) (0 2 2) (0 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (FLET ((F ()
+           ))
+    (FLET ((F (&OPTIONAL (X 1))
+             X
+             #'F
+             (F X)))
+      (F X)
+      #'F))
+  (1 2 2))
+ ((1 2 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (FLET ((F ()
+           ))
+    (FLET ((F (&OPTIONAL (X 1))
+             X
+             #'F
+             (F X)))
+      (F X)
+      #'F))
+  (1 2 2))
+ ((1 2 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (FLET ((F ()
+           ))
+    (FLET ((F (&OPTIONAL (X 1))
+             X
+             #'F
+             (F X)))
+      (F X)
+      #'F))
+  (3 2))
+ ((3 2) (0 2 2) (0 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F ()
+             (F)))
+    (LABELS ((F (&OPTIONAL (X 1))
+               X
+               (F X)))
+      #'F))
+  (0 0 1))
+ ((0 2 0 1) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F ()
+             (F)))
+    (LABELS ((F (&OPTIONAL (X 1))
+               X
+               (F X)))
+      #'F))
+  (0 2 0 1))
+ ((0 2 0 1) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F ()
+             (F)))
+    (LABELS ((F (&OPTIONAL (X 1))
+               X
+               (F X)))
+      #'F))
+  (0 0 1 2))
+ ((2 2) (0 3 0 1 2) (0 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F ()
+             (F)))
+    (LABELS ((F (&OPTIONAL (X 1))
+               X
+               (F X)))
+      #'F))
+  (0 1 1 0 1 2))
+ ((1 3 0 1 2) (2 0 1 2) (0 1 1 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F ()
+             (F)))
+    (LABELS ((F (&OPTIONAL (X 1))
+               X
+               (F X)))
+      #'F))
+  (2 0 1 2))
+ ((1 3 0 1 2) (2 0 1 2) (0 1 1 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F ()
+             (F)))
+    (LABELS ((F (&OPTIONAL (X 1))
+               X
+               (F X)))
+      #'F))
+  (0 3 0 1 2))
+ ((2 2) (0 3 0 1 2) (0 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F ()
+             (F)))
+    (LABELS ((F (&OPTIONAL (X 1))
+               X
+               (F X)))
+      #'F))
+  (1 3 0 1 2))
+ ((1 3 0 1 2) (2 0 1 2) (0 1 1 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F ()
+             (F)))
+    (LABELS ((F (&OPTIONAL (X 1))
+               X
+               (F X)))
+      #'F))
+  (2 2))
+ ((2 2) (0 3 0 1 2) (0 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F (X &KEY (Y X))
+             (G X))
+           (G (Y)
+             (F Y)))
+    (G 10))
+  (0 0 1))
+ ((0 2 1 1) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F (X &KEY (Y X))
+             (G X))
+           (G (Y)
+             (F Y)))
+    (G 10))
+  (0 1 0 1))
+ ((1 2 0 1) (1 2 1 0 1) (0 1 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F (X &KEY (Y X))
+             (G X))
+           (G (Y)
+             (F Y)))
+    (G 10))
+  (0 2 1 0 1))
+ ((0 2 1 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F (X &KEY (Y X))
+             (G X))
+           (G (Y)
+             (F Y)))
+    (G 10))
+  (1 2 1 0 1))
+ ((1 2 0 1) (1 2 1 0 1) (0 1 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F (X &KEY (Y X))
+             (G X))
+           (G (Y)
+             (F Y)))
+    (G 10))
+  (0 2 0 1))
+ ((0 2) (0 1 1) (0 2 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F (X &KEY (Y X))
+             (G X))
+           (G (Y)
+             (F Y)))
+    (G 10))
+  (1 2 0 1))
+ ((1 2 0 1) (1 2 1 0 1) (0 1 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F (X &KEY (Y X))
+             (G X))
+           (G (Y)
+             (F Y)))
+    (G 10))
+  (0 1 1))
+ ((0 2) (0 1 1) (0 2 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F (X &KEY (Y X))
+             (G X))
+           (G (Y)
+             (F Y)))
+    (G 10))
+  (0 1 1 1))
+ ((1 2 1 1) (0 1 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F (X &KEY (Y X))
+             (G X))
+           (G (Y)
+             (F Y)))
+    (G 10))
+  (0 2 1 1))
+ ((0 2 1 1) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F (X &KEY (Y X))
+             (G X))
+           (G (Y)
+             (F Y)))
+    (G 10))
+  (1 2 1 1))
+ ((1 2 1 1) (0 1 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F (X &KEY (Y X))
+             (G X))
+           (G (Y)
+             (F Y)))
+    (G 10))
+  (0 2))
+ ((0 2) (0 1 1) (0 2 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0))
+    (DO ((X 1 (1+ X)))
+        ((= 10 X))
+      A
+      (LET ((A 1))
+        A)
+      B
+      C))
+  (0 0 1))
+ ((3 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0))
+    (DO ((X 1 (1+ X)))
+        ((= 10 X))
+      A
+      (LET ((A 1))
+        A)
+      B
+      C))
+  (0 0 1 2))
+ NIL)
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0))
+    (DO ((X 1 (1+ X)))
+        ((= 10 X))
+      A
+      (LET ((A 1))
+        A)
+      B
+      C))
+  (3 2))
+ ((3 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0))
+    (DO ((X 1 (1+ X)))
+        ((= 10 X))
+      A
+      (LET ((A 1))
+        A)
+      B
+      C))
+  (0 1 4 2))
+ NIL)
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0))
+    (DO ((X 1 (1+ X)))
+        ((= 10 X))
+      A
+      (LET ((A 1))
+        A)
+      B
+      C))
+  (0 0 1 4 2))
+ ((2 4 2) (0 0 1 4 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0))
+    (DO ((X 1 (1+ X)))
+        ((= 10 X))
+      A
+      (LET ((A 1))
+        A)
+      B
+      C))
+  (2 4 2))
+ ((2 4 2) (0 0 1 4 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0))
+    (DO ((X 1 (1+ X)))
+        ((= 10 X))
+      A
+      (LET ((A 1))
+        A)
+      B
+      C))
+  (5 2))
+ ((5 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0))
+    (DO ((X 1 (1+ X)))
+        ((= 10 X))
+      A
+      (LET ((A 1))
+        A)
+      B
+      C))
+  (6 2))
+ ((6 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0))
+    (WITH-HOGE NIL A B C))
+  (0 0 1))
+ ((2 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE)
+    (LET ((A 0))
+      A))
+  (0 0 1 2))
+ ((2 2) (0 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE)
+    (LET ((A 0))
+      A))
+  (2 2))
+ ((2 2) (0 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (BLOCK FOO
+    (RETURN-FROM FOO 10)
+    (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
+    (RETURN-FROM FOO 40))
+  (1))
+ ((1 4) (1 2) (1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE)
+    (LET ((A 0))
+      A))
+  (2 2))
+ ((2 2) (0 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE)
+    (LET ((A 0))
+      A))
+  (0 0 1 2))
+ ((2 2) (0 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0))
+    (WITH-HOGE NIL A B C))
+  (0 0 1))
+ ((2 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0))
+    (DO ((X 1 (1+ X)))
+        ((= 10 X))
+      A
+      (LET ((A 1))
+        A)
+      B
+      C))
+  (6 2))
+ ((6 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0))
+    (DO ((X 1 (1+ X)))
+        ((= 10 X))
+      A
+      (LET ((A 1))
+        A)
+      B
+      C))
+  (5 2))
+ ((5 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0))
+    (DO ((X 1 (1+ X)))
+        ((= 10 X))
+      A
+      (LET ((A 1))
+        A)
+      B
+      C))
+  (2 4 2))
+ ((2 4 2) (0 0 1 4 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0))
+    (DO ((X 1 (1+ X)))
+        ((= 10 X))
+      A
+      (LET ((A 1))
+        A)
+      B
+      C))
+  (0 0 1 4 2))
+ ((2 4 2) (0 0 1 4 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0))
+    (DO ((X 1 (1+ X)))
+        ((= 10 X))
+      A
+      (LET ((A 1))
+        A)
+      B
+      C))
+  (0 1 4 2))
+ NIL)
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0))
+    (DO ((X 1 (1+ X)))
+        ((= 10 X))
+      A
+      (LET ((A 1))
+        A)
+      B
+      C))
+  (3 2))
+ ((3 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0))
+    (DO ((X 1 (1+ X)))
+        ((= 10 X))
+      A
+      (LET ((A 1))
+        A)
+      B
+      C))
+  (0 0 1 2))
+ NIL)
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0))
+    (DO ((X 1 (1+ X)))
+        ((= 10 X))
+      A
+      (LET ((A 1))
+        A)
+      B
+      C))
+  (0 0 1))
+ ((3 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F (X &KEY (Y X))
+             (G X))
+           (G (Y)
+             (F Y)))
+    (G 10))
+  (0 2))
+ ((0 2) (0 1 1) (0 2 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F (X &KEY (Y X))
+             (G X))
+           (G (Y)
+             (F Y)))
+    (G 10))
+  (1 2 1 1))
+ ((1 2 1 1) (0 1 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F (X &KEY (Y X))
+             (G X))
+           (G (Y)
+             (F Y)))
+    (G 10))
+  (0 2 1 1))
+ ((0 2 1 1) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F (X &KEY (Y X))
+             (G X))
+           (G (Y)
+             (F Y)))
+    (G 10))
+  (0 1 1 1))
+ ((1 2 1 1) (0 1 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F (X &KEY (Y X))
+             (G X))
+           (G (Y)
+             (F Y)))
+    (G 10))
+  (0 1 1))
+ ((0 2) (0 1 1) (0 2 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F (X &KEY (Y X))
+             (G X))
+           (G (Y)
+             (F Y)))
+    (G 10))
+  (1 2 0 1))
+ ((1 2 0 1) (1 2 1 0 1) (0 1 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F (X &KEY (Y X))
+             (G X))
+           (G (Y)
+             (F Y)))
+    (G 10))
+  (0 2 0 1))
+ ((0 2) (0 1 1) (0 2 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F (X &KEY (Y X))
+             (G X))
+           (G (Y)
+             (F Y)))
+    (G 10))
+  (1 2 1 0 1))
+ ((1 2 0 1) (1 2 1 0 1) (0 1 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F (X &KEY (Y X))
+             (G X))
+           (G (Y)
+             (F Y)))
+    (G 10))
+  (0 2 1 0 1))
+ ((0 2 1 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F (X &KEY (Y X))
+             (G X))
+           (G (Y)
+             (F Y)))
+    (G 10))
+  (0 1 0 1))
+ ((1 2 0 1) (1 2 1 0 1) (0 1 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F (X &KEY (Y X))
+             (G X))
+           (G (Y)
+             (F Y)))
+    (G 10))
+  (0 0 1))
+ ((0 2 1 1) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F ()
+             (F)))
+    (LABELS ((F (&OPTIONAL (X 1))
+               X
+               (F X)))
+      #'F))
+  (2 2))
+ ((2 2) (0 3 0 1 2) (0 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F ()
+             (F)))
+    (LABELS ((F (&OPTIONAL (X 1))
+               X
+               (F X)))
+      #'F))
+  (1 3 0 1 2))
+ ((1 3 0 1 2) (2 0 1 2) (0 1 1 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F ()
+             (F)))
+    (LABELS ((F (&OPTIONAL (X 1))
+               X
+               (F X)))
+      #'F))
+  (0 3 0 1 2))
+ ((2 2) (0 3 0 1 2) (0 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F ()
+             (F)))
+    (LABELS ((F (&OPTIONAL (X 1))
+               X
+               (F X)))
+      #'F))
+  (2 0 1 2))
+ ((1 3 0 1 2) (2 0 1 2) (0 1 1 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F ()
+             (F)))
+    (LABELS ((F (&OPTIONAL (X 1))
+               X
+               (F X)))
+      #'F))
+  (0 1 1 0 1 2))
+ ((1 3 0 1 2) (2 0 1 2) (0 1 1 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F ()
+             (F)))
+    (LABELS ((F (&OPTIONAL (X 1))
+               X
+               (F X)))
+      #'F))
+  (0 0 1 2))
+ ((2 2) (0 3 0 1 2) (0 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F ()
+             (F)))
+    (LABELS ((F (&OPTIONAL (X 1))
+               X
+               (F X)))
+      #'F))
+  (0 2 0 1))
+ ((0 2 0 1) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LABELS ((F ()
+             (F)))
+    (LABELS ((F (&OPTIONAL (X 1))
+               X
+               (F X)))
+      #'F))
+  (0 0 1))
+ ((0 2 0 1) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (FLET ((F ()
+           ))
+    (FLET ((F (&OPTIONAL (X 1))
+             X
+             #'F
+             (F X)))
+      (F X)
+      #'F))
+  (3 2))
+ ((3 2) (0 2 2) (0 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (FLET ((F ()
+           ))
+    (FLET ((F (&OPTIONAL (X 1))
+             X
+             #'F
+             (F X)))
+      (F X)
+      #'F))
+  (1 2 2))
+ ((1 2 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (FLET ((F ()
+           ))
+    (FLET ((F (&OPTIONAL (X 1))
+             X
+             #'F
+             (F X)))
+      (F X)
+      #'F))
+  (1 2 2))
+ ((1 2 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (FLET ((F ()
+           ))
+    (FLET ((F (&OPTIONAL (X 1))
+             X
+             #'F
+             (F X)))
+      (F X)
+      #'F))
+  (0 2 2))
+ ((3 2) (0 2 2) (0 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (FLET ((F ()
+           ))
+    (FLET ((F (&OPTIONAL (X 1))
+             X
+             #'F
+             (F X)))
+      (F X)
+      #'F))
+  (1 4 0 1 2))
+ ((1 4 0 1 2) (2 0 1 2) (0 1 1 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (FLET ((F ()
+           ))
+    (FLET ((F (&OPTIONAL (X 1))
+             X
+             #'F
+             (F X)))
+      (F X)
+      #'F))
+  (0 4 0 1 2))
+ ((0 4 0 1 2) (3 0 1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (FLET ((F ()
+           ))
+    (FLET ((F (&OPTIONAL (X 1))
+             X
+             #'F
+             (F X)))
+      (F X)
+      #'F))
+  (3 0 1 2))
+ ((0 4 0 1 2) (3 0 1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (FLET ((F ()
+           ))
+    (FLET ((F (&OPTIONAL (X 1))
+             X
+             #'F
+             (F X)))
+      (F X)
+      #'F))
+  (4 0 1 2))
+ NIL)
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (FLET ((F ()
+           ))
+    (FLET ((F (&OPTIONAL (X 1))
+             X
+             #'F
+             (F X)))
+      (F X)
+      #'F))
+  (2 0 1 2))
+ ((1 4 0 1 2) (2 0 1 2) (0 1 1 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (FLET ((F ()
+           ))
+    (FLET ((F (&OPTIONAL (X 1))
+             X
+             #'F
+             (F X)))
+      (F X)
+      #'F))
+  (0 1 1 0 1 2))
+ ((1 4 0 1 2) (2 0 1 2) (0 1 1 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (FLET ((F ()
+           ))
+    (FLET ((F (&OPTIONAL (X 1))
+             X
+             #'F
+             (F X)))
+      (F X)
+      #'F))
+  (0 0 1 2))
+ ((3 2) (0 2 2) (0 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (FLET ((F ()
+           ))
+    (FLET ((F (&OPTIONAL (X 1))
+             X
+             #'F
+             (F X)))
+      (F X)
+      #'F))
+  (1 1 2))
+ NIL)
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (FLET ((F ()
+           ))
+    (FLET ((F (&OPTIONAL (X 1))
+             X
+             #'F
+             (F X)))
+      (F X)
+      #'F))
+  (0 0 1))
+ ((0 4 0 1 2) (3 0 1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (5 1))
+ ((5 1) (0 8 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (4 1))
+ ((4 1) (6 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (3 1))
+ ((3 1) (0 5 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (2 1))
+ ((2 1) (1 5 1 1) (0 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
+                                        (0 8 1 1))
+ ((5 1) (0 8 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
+                                        (6 1 1))
+ ((4 1) (6 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
+                                        (1 5 1 1))
+ ((2 1) (1 5 1 1) (0 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
+                                        (0 5 1 1))
+ ((3 1) (0 5 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
+                                        (3 1 1))
+ ((3 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
+                                        (2 1 1))
+ ((2 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
+                                        (1 1 1))
+ ((1 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
+                                        (0 1 1))
+ ((2 1) (1 5 1 1) (0 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (5))
+ ((5) (0 8 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (4))
+ ((4) (6 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (3))
+ ((3) (0 5 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (2))
+ ((2) (1 5 1) (0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (0 8 1))
+ ((5) (0 8 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (6 1))
+ ((4) (6 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (1 5 1))
+ ((2) (1 5 1) (0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (0 5 1))
+ ((3) (0 5 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (3 1))
+ ((3 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (2 1))
+ ((2 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (1 1))
+ ((1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (0 1))
+ ((2) (1 5 1) (0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (3 7))
+ ((3 7)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (2 2 7))
+ ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (1 7))
+ ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (3 6))
+ ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (2 6))
+ ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (1 6))
+ ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (2 5))
+ ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (1 5))
+ ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (4 4))
+ ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (3 4))
+ ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (2 4))
+ ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (1 4))
+ ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (4 3))
+ ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (3 3))
+ ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (2 3))
+ ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (2 2))
+ ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (2 2))
+ ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (1 2))
+ ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (0 1 1))
+ ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 0) (B 1))
+    (LOAD-TIME-VALUE A B)
+    (MULTIPLE-VALUE-CALL 'F A B A)
+    (SETQ A B
+          B A)
+    (PROGN A B)
+    (MULTIPLE-VALUE-PROG1 A B A)
+    (UNWIND-PROTECT A (THE INTEGER B) C))
+  (0 0 1))
+ ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 1))
+    (LET ((B A))
+      A
+      B))
+  (3 2))
+ ((3 2) (0 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 1))
+    (LET ((B A))
+      A
+      B))
+  (2 2))
+ ((2 2) (1 0 1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 1))
+    (LET ((B A))
+      A
+      B))
+  (1 0 1 2))
+ ((2 2) (1 0 1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 1))
+    (LET ((B A))
+      A
+      B))
+  (0 0 1 2))
+ ((3 2) (0 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((A 1))
+    (LET ((B A))
+      A
+      B))
+  (0 0 1))
+ ((2 2) (1 0 1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET* ((A 0) (B A))
+    (LET* ((A A) (B A))
+      A)
+    A)
+  (3))
+ ((3) (1 0 1 2) (1 1 1) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET* ((A 0) (B A))
+    (LET* ((A A) (B A))
+      A)
+    A)
+  (2 2))
+ ((2 2) (1 1 1 2) (0 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET* ((A 0) (B A))
+    (LET* ((A A) (B A))
+      A)
+    A)
+  (1 1 1 2))
+ ((2 2) (1 1 1 2) (0 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET* ((A 0) (B A))
+    (LET* ((A A) (B A))
+      A)
+    A)
+  (0 1 1 2))
+ ((0 1 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET* ((A 0) (B A))
+    (LET* ((A A) (B A))
+      A)
+    A)
+  (1 0 1 2))
+ ((3) (1 0 1 2) (1 1 1) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET* ((A 0) (B A))
+    (LET* ((A A) (B A))
+      A)
+    A)
+  (0 0 1 2))
+ ((2 2) (1 1 1 2) (0 0 1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET* ((A 0) (B A))
+    (LET* ((A A) (B A))
+      A)
+    A)
+  (1 1 1))
+ ((3) (1 0 1 2) (1 1 1) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET* ((A 0) (B A))
+    (LET* ((A A) (B A))
+      A)
+    A)
+  (0 1 1))
+ ((0 1 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET* ((A 0) (B A))
+    (LET* ((A A) (B A))
+      A)
+    A)
+  (0 0 1))
+ ((3) (1 0 1 2) (1 1 1) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (BLOCK FOO
+    (RETURN-FROM FOO 10)
+    (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
+    (RETURN-FROM FOO 40))
+  (1 4))
+ ((1 4) (1 2) (1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (BLOCK FOO
+    (RETURN-FROM FOO 10)
+    (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
+    (RETURN-FROM FOO 40))
+  (1 3 3))
+ ((1 3 3) (1 2 3) (1 3)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (BLOCK FOO
+    (RETURN-FROM FOO 10)
+    (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
+    (RETURN-FROM FOO 40))
+  (1 2 3))
+ ((1 3 3) (1 2 3) (1 3)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (BLOCK FOO
+    (RETURN-FROM FOO 10)
+    (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
+    (RETURN-FROM FOO 40))
+  (1 3))
+ ((1 3 3) (1 2 3) (1 3)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (BLOCK FOO
+    (RETURN-FROM FOO 10)
+    (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
+    (RETURN-FROM FOO 40))
+  (1 2))
+ ((1 4) (1 2) (1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (BLOCK FOO
+    (RETURN-FROM FOO 10)
+    (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
+    (RETURN-FROM FOO 40))
+  (1))
+ ((1 4) (1 2) (1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS FOO NIL) NIL)
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS FOO NIL) NIL)
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS FOO NIL) NIL)
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (BLOCK FOO
+    (RETURN-FROM FOO 10)
+    (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
+    (RETURN-FROM FOO 40))
+  (1))
+ ((1 4) (1 2) (1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFUN F (X Y) X Y X Y) (6)) ((6) (4) (1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFUN F (X Y) X Y X Y) (5)) ((5) (3) (0 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFUN F (X Y) X Y X Y) (4)) ((6) (4) (1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFUN F (X Y) X Y X Y) (3)) ((5) (3) (0 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFUN F (X Y) X Y X Y) (1 2)) ((6) (4) (1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFUN F (X Y) X Y X Y) (0 2)) ((5) (3) (0 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFMETHOD ADD (X Y) (+ X Y)) (2 3)) ((2 3) (1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFMETHOD ADD (X Y) (+ X Y)) (1 3)) ((1 3) (0 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFMETHOD ADD (X Y) (+ X Y)) (1 2)) ((2 3) (1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFMETHOD ADD (X Y) (+ X Y)) (0 2)) ((1 3) (0 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (DEFMETHOD MICROS/WALKER::ADD (MICROS/WALKER::X MICROS/WALKER::Y) (+ MICROS/WALKER::X MICROS/WALKER::Y))
+  (2 3))
+ ((2 3) (1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (DEFMETHOD MICROS/WALKER::ADD (MICROS/WALKER::X MICROS/WALKER::Y) (+ MICROS/WALKER::X MICROS/WALKER::Y))
+  (1 3))
+ ((1 3) (0 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (DEFMETHOD MICROS/WALKER::ADD (MICROS/WALKER::X MICROS/WALKER::Y) (+ MICROS/WALKER::X MICROS/WALKER::Y))
+  (1 2))
+ ((2 3) (1 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (DEFMETHOD MICROS/WALKER::ADD (MICROS/WALKER::X MICROS/WALKER::Y) (+ MICROS/WALKER::X MICROS/WALKER::Y))
+  (0 2))
+ ((1 3) (0 2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFMETHOD ADD :BEFORE ((X INTEGER) (Y INTEGER)) (PRINT (LIST X Y)))
+                                        (2 1 4))
+ ((2 1 4) (0 1 3)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFMETHOD ADD :BEFORE ((X INTEGER) (Y INTEGER)) (PRINT (LIST X Y)))
+                                        (1 1 4))
+ ((1 1 4) (0 0 3)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFMETHOD ADD :BEFORE ((X INTEGER) (Y INTEGER)) (PRINT (LIST X Y)))
+                                        (0 1 3))
+ ((2 1 4) (0 1 3)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFMETHOD ADD :BEFORE ((X INTEGER) (Y INTEGER)) (PRINT (LIST X Y)))
+                                        (0 0 3))
+ ((1 1 4) (0 0 3)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  ((LAMBDA (MICROS/WALKER::A MICROS/WALKER::B) (+ MICROS/WALKER::A MICROS/WALKER::B)) 1 2) (2 2 0))
+ ((2 2 0) (1 1 0)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  ((LAMBDA (MICROS/WALKER::A MICROS/WALKER::B) (+ MICROS/WALKER::A MICROS/WALKER::B)) 1 2) (1 2 0))
+ ((1 2 0) (0 1 0)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  ((LAMBDA (MICROS/WALKER::A MICROS/WALKER::B) (+ MICROS/WALKER::A MICROS/WALKER::B)) 1 2) (1 1 0))
+ ((2 2 0) (1 1 0)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  ((LAMBDA (MICROS/WALKER::A MICROS/WALKER::B) (+ MICROS/WALKER::A MICROS/WALKER::B)) 1 2)
+  (0 1 0))
+ ((1 2 0) (0 1 0)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((COMMON-LISP-USER::A 0))
+    COMMON-LISP-USER::A
+    ((LAMBDA (COMMON-LISP-USER::A) (DECLARE (SPECIAL COMMON-LISP-USER::A)) COMMON-LISP-USER::A))
+    ((LAMBDA (COMMON-LISP-USER::A) (DECLARE (SPECIAL COMMON-LISP-USER::A)) COMMON-LISP-USER::A))
+    COMMON-LISP-USER::A)
+  (3 0 3))
+ ((3 0 4) (0 1 0 4) (3 0 3) (0 1 0 3)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((X 0))
+    (LOOP (F X)))
+  (1 1 2))
+ ((1 1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LET ((X 0))
+    (LOOP (F X)))
+  (0 0 1))
+ ((1 1 2) (0 0 1)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH X := 0
+        :WITH Y := X
+        :WITH Z := (F X Y))
+  (2 12))
+ ((6) (2 12)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH X := 0
+        :WITH Y := X
+        :WITH Z := (F X Y))
+  (1 12))
+ ((2) (8) (1 12)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH X := 0
+        :WITH Y := X
+        :WITH Z := (F X Y))
+  (8))
+ ((2) (8) (1 12)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH X := 0
+        :WITH Y := X
+        :WITH Z := (F X Y))
+  (10))
+ ((10)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH X := 0
+        :WITH Y := X
+        :WITH Z := (F X Y))
+  (6))
+ ((6) (2 12)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH X := 0
+        :WITH Y := X
+        :WITH Z := (F X Y))
+  (2))
+ ((2) (8) (1 12)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH X := 0
+        :DO (F X))
+  (1 6))
+ ((1 6) (2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH X := 0
+        :DO (F X))
+  (2))
+ ((1 6) (2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LOOP :WITH X := 0 :RETURN :IT :RETURN (F X)) (6))
+ NIL)
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LOOP :WITH X := 0 :RETURN :IT :RETURN (F X)) (1 8))
+ ((1 8) (2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LOOP :WITH X := 0 :RETURN :IT :RETURN (F X)) (2))
+ ((1 8) (2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH ((X Y) . Z) := (F)
+        :WITH A := (+ X Y Z))
+  (3 8))
+ ((2 2) (3 8)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH ((X Y) . Z) := (F)
+        :WITH A := (+ X Y Z))
+  (2 8))
+ ((1 0 2) (2 8)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH ((X Y) . Z) := (F)
+        :WITH A := (+ X Y Z))
+  (1 8))
+ ((0 0 2) (1 8)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH ((X Y) . Z) := (F)
+        :WITH A := (+ X Y Z))
+  (2 2))
+ ((2 2) (3 8)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH ((X Y) . Z) := (F)
+        :WITH A := (+ X Y Z))
+  (1 0 2))
+ ((1 0 2) (2 8)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH ((X Y) . Z) := (F)
+        :WITH A := (+ X Y Z))
+  (0 0 2))
+ ((0 0 2) (1 8)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH (X . Y) := (F)
+        :WITH A := X
+        :WITH B := Y)
+  (12))
+ ((2 2) (12)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH (X . Y) := (F)
+        :WITH A := X
+        :WITH B := Y)
+  (8))
+ ((0 2) (8)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH (X . Y) := (F)
+        :WITH A := X
+        :WITH B := Y)
+  (2 2))
+ ((2 2) (12)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH (X . Y) := (F)
+        :WITH A := X
+        :WITH B := Y)
+  (0 2))
+ ((0 2) (8)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH FOO := NIL
+        :FOR X :IN '(1 2 3)
+        :DO (PRINT X))
+  (1 10))
+ ((1 10) (6)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH FOO := NIL
+        :FOR X :IN '(1 2 3)
+        :DO (PRINT X))
+  (6))
+ ((1 10) (6)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH FOO := NIL
+        :FOR X :IN '(1 2 3)
+        :DO (PRINT X))
+  (2))
+ ((2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH FOO
+        :FOR X :IN '(1 2 3)
+        :DO (PRINT X))
+  (1 8))
+ ((1 8) (4)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH FOO
+        :FOR X :IN '(1 2 3)
+        :DO (PRINT X))
+  (4))
+ ((1 8) (4)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH FOO
+        :FOR X :IN '(1 2 3)
+        :DO (PRINT X))
+  (2))
+ ((2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :FOR X :IN '(1 2 3)
+        :DO (PRINT X))
+  (1 6))
+ ((1 6) (2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :FOR X :IN '(1 2 3)
+        :DO (PRINT X))
+  (2))
+ ((1 6) (2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH FN := #'CDDR
+        :AND A
+        :FOR X :IN (LIST A) :BY FN
+        :DO (PRINT X))
+  (1 14))
+ ((1 14) (8)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH FN := #'CDDR
+        :AND A
+        :FOR X :IN (LIST A) :BY FN
+        :DO (PRINT X))
+  (12))
+ ((12) (2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH FN := #'CDDR
+        :AND A
+        :FOR X :IN (LIST A) :BY FN
+        :DO (PRINT X))
+  (1 10))
+ ((1 10) (6)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH FN := #'CDDR
+        :AND A
+        :FOR X :IN (LIST A) :BY FN
+        :DO (PRINT X))
+  (8))
+ ((1 14) (8)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH FN := #'CDDR
+        :AND A
+        :FOR X :IN (LIST A) :BY FN
+        :DO (PRINT X))
+  (6))
+ ((1 10) (6)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH FN := #'CDDR
+        :AND A
+        :FOR X :IN (LIST A) :BY FN
+        :DO (PRINT X))
+  (2))
+ ((12) (2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH FN := #'CDDR
+        :AND A
+        :FOR X :ON (LIST A) :BY FN
+        :DO (PRINT X))
+  (1 14))
+ ((1 14) (8)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH FN := #'CDDR
+        :AND A
+        :FOR X :ON (LIST A) :BY FN
+        :DO (PRINT X))
+  (12))
+ ((12) (2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH FN := #'CDDR
+        :AND A
+        :FOR X :ON (LIST A) :BY FN
+        :DO (PRINT X))
+  (1 10))
+ ((1 10) (6)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH FN := #'CDDR
+        :AND A
+        :FOR X :ON (LIST A) :BY FN
+        :DO (PRINT X))
+  (8))
+ ((1 14) (8)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH FN := #'CDDR
+        :AND A
+        :FOR X :ON (LIST A) :BY FN
+        :DO (PRINT X))
+  (2))
+ ((12) (2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH FOO := NIL
+        :FOR X :ON '(1 2 3)
+        :DO (PRINT X))
+  (1 10))
+ ((1 10) (6)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH FOO := NIL
+        :FOR X :ON '(1 2 3)
+        :DO (PRINT X))
+  (6))
+ ((1 10) (6)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH FOO := NIL
+        :FOR X :ON '(1 2 3)
+        :DO (PRINT X))
+  (2))
+ ((2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH FOO
+        :FOR X :ON '(1 2 3)
+        :DO (PRINT X))
+  (1 8))
+ ((1 8) (4)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH FOO
+        :FOR X :ON '(1 2 3)
+        :DO (PRINT X))
+  (4))
+ ((1 8) (4)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :WITH FOO
+        :FOR X :ON '(1 2 3)
+        :DO (PRINT X))
+  (2))
+ ((2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :FOR X :ON '(1 2 3)
+        :DO (PRINT X))
+  (1 6))
+ ((1 6) (2)))
+((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
+  (LOOP :FOR X :ON '(1 2 3)
+        :DO (PRINT X))
+  (2))
+ ((1 6) (2)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LOOP :FOR X := 1 :THEN (F X)
+        :DO (F X))
+  (1 8))
+ ((1 8) (1 6) (2)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LOOP :FOR X := 1 :THEN (F X)
+        :DO (F X))
+  (1 6))
+ ((1 8) (1 6) (2)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LOOP :FOR X := 1 :THEN (F X)
+        :DO (F X))
+  (2))
+ ((1 8) (1 6) (2)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LOOP :FOR X := 1
+        :DO (F X))
+  (1 6))
+ ((1 6) (2)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LOOP :FOR X := 1
+        :DO (F X))
+  (2))
+ ((1 6) (2)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LOOP :FOR X :ACROSS '(1 2 3)
+        :DO (F X))
+  (1 6))
+ ((1 6) (2)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LOOP :FOR X :ACROSS '(1 2 3)
+        :DO (F X))
+  (2))
+ ((1 6) (2)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LOOP :FOR (X . Y) := (F)
+        :DO (F X Y))
+  (2 6))
+ ((2 6) (2 2)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LOOP :FOR (X . Y) := (F)
+        :DO (F X Y))
+  (1 6))
+ ((1 6) (0 2)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LOOP :FOR (X . Y) := (F)
+        :DO (F X Y))
+  (2 2))
+ ((2 6) (2 2)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LOOP :FOR (X . Y) := (F)
+        :DO (F X Y))
+  (0 2))
+ ((1 6) (0 2)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LOOP FOR K BEING EACH HASH-KEY IN (PLIST-HASH-TABLE '((:A) 1 (:B) 2)) USING (HASH-VALUE V)
+        DO (PRINT (CONS K V)))
+  (2 1 11))
+ ((2 1 11) (1 9)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LOOP FOR K BEING EACH HASH-KEY IN (PLIST-HASH-TABLE '((:A) 1 (:B) 2)) USING (HASH-VALUE V)
+        DO (PRINT (CONS K V)))
+  (1 1 11))
+ ((1 1 11) (2)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LOOP FOR K BEING EACH HASH-KEY IN (PLIST-HASH-TABLE '((:A) 1 (:B) 2)) USING (HASH-VALUE V)
+        DO (PRINT (CONS K V)))
+  (1 9))
+ ((2 1 11) (1 9)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LOOP FOR K BEING EACH HASH-KEY IN (PLIST-HASH-TABLE '((:A) 1 (:B) 2)) USING (HASH-VALUE V)
+        DO (PRINT (CONS K V)))
+  (2))
+ ((1 1 11) (2)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LOOP FOR K BEING EACH HASH-KEY IN (PLIST-HASH-TABLE '((:A) 1 (:B) 2))
+        DO (PRINT K))
+  (1 9))
+ ((1 9) (2)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LOOP FOR K BEING EACH HASH-KEY IN (PLIST-HASH-TABLE '((:A) 1 (:B) 2))
+        DO (PRINT K))
+  (2))
+ ((1 9) (2)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LET ((V 0))
+    (LOOP FOR K BEING EACH HASH-KEY IN (PLIST-HASH-TABLE '((:A) 1 (:B) 2)) USING (HASH-VALUE
+                                                                                  V)
+          DO (PRINT (CONS K V)))
+    V)
+  (0 0 1))
+ ((3) (0 0 1)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LET ((V 0))
+    (LOOP FOR K BEING EACH HASH-KEY IN (PLIST-HASH-TABLE '((:A) 1 (:B) 2)) USING (HASH-VALUE
+                                                                                  V)
+          DO (PRINT (CONS K V)))
+    V)
+  (3))
+ ((3) (0 0 1)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LET ((V 0))
+    (LOOP FOR K BEING EACH HASH-KEY IN (PLIST-HASH-TABLE '((:A) 1 (:B) 2)) USING (HASH-VALUE
+                                                                                  V)
+          DO (PRINT (CONS K V)))
+    V)
+  (2 1 11 2))
+ ((2 1 11 2) (1 9 2)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LET ((V 0))
+    (LOOP FOR K BEING EACH HASH-KEY IN (PLIST-HASH-TABLE '((:A) 1 (:B) 2)) USING (HASH-VALUE
+                                                                                  V)
+          DO (PRINT (CONS K V)))
+    V)
+  (1 9 2))
+ ((2 1 11 2) (1 9 2)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LOOP FOR V BEING EACH HASH-VALUES OF *HT* USING (HASH-KEY K)
+        DO (FORMAT T "~a=>~a~%" K V))
+  (4 11))
+ ((4 11) (2)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LOOP FOR V BEING EACH HASH-VALUES OF *HT* USING (HASH-KEY K)
+        DO (FORMAT T "~a=>~a~%" K V))
+  (3 11))
+ ((3 11) (1 9)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LOOP FOR V BEING EACH HASH-VALUES OF *HT* USING (HASH-KEY K)
+        DO (FORMAT T "~a=>~a~%" K V))
+  (1 9))
+ ((3 11) (1 9)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LOOP FOR V BEING EACH HASH-VALUES OF *HT* USING (HASH-KEY K)
+        DO (FORMAT T "~a=>~a~%" K V))
+  (2))
+ ((4 11) (2)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LOOP FOR V BEING THE HASH-VALUE IN *HT*
+        DO (PRINT V))
+  (1 9))
+ ((1 9) (2)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LOOP FOR V BEING THE HASH-VALUE IN *HT*
+        DO (PRINT V))
+  (2))
+ ((1 9) (2)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LET ((PACKAGE-NAME (F)))
+    (LOOP :FOR NAME :BEING :EACH :EXTERNAL-SYMBOL :IN PACKAGE-NAME
+          :DO (PRINT NAME)))
+  (1 9 2))
+ ((1 9 2) (2 2)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LET ((PACKAGE-NAME (F)))
+    (LOOP :FOR NAME :BEING :EACH :EXTERNAL-SYMBOL :IN PACKAGE-NAME
+          :DO (PRINT NAME)))
+  (7 2))
+ ((7 2) (0 0 1)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LET ((PACKAGE-NAME (F)))
+    (LOOP :FOR NAME :BEING :EACH :EXTERNAL-SYMBOL :IN PACKAGE-NAME
+          :DO (PRINT NAME)))
+  (2 2))
+ ((1 9 2) (2 2)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LET ((PACKAGE-NAME (F)))
+    (LOOP :FOR NAME :BEING :EACH :EXTERNAL-SYMBOL :IN PACKAGE-NAME
+          :DO (PRINT NAME)))
+  (0 0 1))
+ ((7 2) (0 0 1)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LOOP :FOR NAME :BEING :EACH :EXTERNAL-SYMBOL
+        :DO (PRINT NAME))
+  (1 7))
+ ((1 7) (2)))
+((COLLECT-HIGHLIGHT-PATHS
+  (LOOP :FOR NAME :BEING :EACH :EXTERNAL-SYMBOL
+        :DO (PRINT NAME))
+  (2))
+ ((1 7) (2)))
diff --git a/contrib/walker/tests/tests.lisp b/contrib/walker/tests/tests.lisp
index e1d6647..eb2e442 100644
--- a/contrib/walker/tests/tests.lisp
+++ b/contrib/walker/tests/tests.lisp
@@ -2,1860 +2,11 @@
   (:use #:cl #:rove))
 (in-package #:micros/walker/tests)
 
-(defvar *test-cases*
-  '(((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (BLOCK FOO
-        (RETURN-FROM FOO 10)
-        (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
-        (RETURN-FROM FOO 40))
-      (1))
-     ((1 4) (1 2) (1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS FOO NIL) NIL)
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS FOO NIL) NIL)
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS FOO NIL) NIL)
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (BLOCK FOO
-        (RETURN-FROM FOO 10)
-        (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
-        (RETURN-FROM FOO 40))
-      (1))
-     ((1 4) (1 2) (1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (BLOCK FOO
-        (RETURN-FROM FOO 10)
-        (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
-        (RETURN-FROM FOO 40))
-      (1 2))
-     ((1 4) (1 2) (1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (BLOCK FOO
-        (RETURN-FROM FOO 10)
-        (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
-        (RETURN-FROM FOO 40))
-      (1 3))
-     ((1 3 3) (1 2 3) (1 3)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (BLOCK FOO
-        (RETURN-FROM FOO 10)
-        (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
-        (RETURN-FROM FOO 40))
-      (1 2 3))
-     ((1 3 3) (1 2 3) (1 3)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (BLOCK FOO
-        (RETURN-FROM FOO 10)
-        (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
-        (RETURN-FROM FOO 40))
-      (1 3 3))
-     ((1 3 3) (1 2 3) (1 3)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (BLOCK FOO
-        (RETURN-FROM FOO 10)
-        (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
-        (RETURN-FROM FOO 40))
-      (1 4))
-     ((1 4) (1 2) (1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET* ((A 0) (B A))
-        (LET* ((A A) (B A))
-          A)
-        A)
-      (0 0 1))
-     ((3) (1 0 1 2) (1 1 1) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET* ((A 0) (B A))
-        (LET* ((A A) (B A))
-          A)
-        A)
-      (0 1 1))
-     ((0 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET* ((A 0) (B A))
-        (LET* ((A A) (B A))
-          A)
-        A)
-      (1 1 1))
-     ((3) (1 0 1 2) (1 1 1) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET* ((A 0) (B A))
-        (LET* ((A A) (B A))
-          A)
-        A)
-      (0 0 1 2))
-     ((2 2) (1 1 1 2) (0 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET* ((A 0) (B A))
-        (LET* ((A A) (B A))
-          A)
-        A)
-      (1 0 1 2))
-     ((3) (1 0 1 2) (1 1 1) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET* ((A 0) (B A))
-        (LET* ((A A) (B A))
-          A)
-        A)
-      (0 1 1 2))
-     ((0 1 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET* ((A 0) (B A))
-        (LET* ((A A) (B A))
-          A)
-        A)
-      (1 1 1 2))
-     ((2 2) (1 1 1 2) (0 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET* ((A 0) (B A))
-        (LET* ((A A) (B A))
-          A)
-        A)
-      (2 2))
-     ((2 2) (1 1 1 2) (0 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET* ((A 0) (B A))
-        (LET* ((A A) (B A))
-          A)
-        A)
-      (3))
-     ((3) (1 0 1 2) (1 1 1) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 1))
-        (LET ((B A))
-          A
-          B))
-      (0 0 1))
-     ((2 2) (1 0 1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 1))
-        (LET ((B A))
-          A
-          B))
-      (0 0 1 2))
-     ((3 2) (0 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 1))
-        (LET ((B A))
-          A
-          B))
-      (1 0 1 2))
-     ((2 2) (1 0 1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 1))
-        (LET ((B A))
-          A
-          B))
-      (2 2))
-     ((2 2) (1 0 1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 1))
-        (LET ((B A))
-          A
-          B))
-      (3 2))
-     ((3 2) (0 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (0 0 1))
-     ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (0 1 1))
-     ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (1 2))
-     ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (2 2))
-     ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (2 2))
-     ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (2 3))
-     ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (3 3))
-     ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (4 3))
-     ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (1 4))
-     ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (2 4))
-     ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (3 4))
-     ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (4 4))
-     ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (1 5))
-     ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (2 5))
-     ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (1 6))
-     ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (2 6))
-     ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (3 6))
-     ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (1 7))
-     ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (2 2 7))
-     ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (3 7))
-     ((3 7)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (0 1))
-     ((2) (1 5 1) (0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (1 1))
-     ((1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (2 1))
-     ((2 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (3 1))
-     ((3 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (0 5 1))
-     ((3) (0 5 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (1 5 1))
-     ((2) (1 5 1) (0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (6 1))
-     ((4) (6 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (0 8 1))
-     ((5) (0 8 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (2))
-     ((2) (1 5 1) (0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (3))
-     ((3) (0 5 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (4))
-     ((4) (6 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (5))
-     ((5) (0 8 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
-      (0 1 1))
-     ((2 1) (1 5 1 1) (0 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
-      (1 1 1))
-     ((1 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
-      (2 1 1))
-     ((2 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
-      (3 1 1))
-     ((3 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
-      (0 5 1 1))
-     ((3 1) (0 5 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
-      (1 5 1 1))
-     ((2 1) (1 5 1 1) (0 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
-      (6 1 1))
-     ((4 1) (6 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
-      (0 8 1 1))
-     ((5 1) (0 8 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (2 1))
-     ((2 1) (1 5 1 1) (0 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (3 1))
-     ((3 1) (0 5 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (4 1))
-     ((4 1) (6 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (5 1))
-     ((5 1) (0 8 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (FLET ((F ()
-               ))
-        (FLET ((F (&OPTIONAL (X 1))
-                 X
-                 #'F
-                 (F X)))
-          (F X)
-          #'F))
-      (0 0 1))
-     ((0 4 0 1 2) (3 0 1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (FLET ((F ()
-               ))
-        (FLET ((F (&OPTIONAL (X 1))
-                 X
-                 #'F
-                 (F X)))
-          (F X)
-          #'F))
-      (1 1 2))
-     NIL)
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (FLET ((F ()
-               ))
-        (FLET ((F (&OPTIONAL (X 1))
-                 X
-                 #'F
-                 (F X)))
-          (F X)
-          #'F))
-      (0 0 1 2))
-     ((3 2) (0 2 2) (0 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (FLET ((F ()
-               ))
-        (FLET ((F (&OPTIONAL (X 1))
-                 X
-                 #'F
-                 (F X)))
-          (F X)
-          #'F))
-      (0 1 1 0 1 2))
-     ((1 4 0 1 2) (2 0 1 2) (0 1 1 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (FLET ((F ()
-               ))
-        (FLET ((F (&OPTIONAL (X 1))
-                 X
-                 #'F
-                 (F X)))
-          (F X)
-          #'F))
-      (2 0 1 2))
-     ((1 4 0 1 2) (2 0 1 2) (0 1 1 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (FLET ((F ()
-               ))
-        (FLET ((F (&OPTIONAL (X 1))
-                 X
-                 #'F
-                 (F X)))
-          (F X)
-          #'F))
-      (4 0 1 2))
-     NIL)
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (FLET ((F ()
-               ))
-        (FLET ((F (&OPTIONAL (X 1))
-                 X
-                 #'F
-                 (F X)))
-          (F X)
-          #'F))
-      (3 0 1 2))
-     ((0 4 0 1 2) (3 0 1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (FLET ((F ()
-               ))
-        (FLET ((F (&OPTIONAL (X 1))
-                 X
-                 #'F
-                 (F X)))
-          (F X)
-          #'F))
-      (0 4 0 1 2))
-     ((0 4 0 1 2) (3 0 1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (FLET ((F ()
-               ))
-        (FLET ((F (&OPTIONAL (X 1))
-                 X
-                 #'F
-                 (F X)))
-          (F X)
-          #'F))
-      (1 4 0 1 2))
-     ((1 4 0 1 2) (2 0 1 2) (0 1 1 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (FLET ((F ()
-               ))
-        (FLET ((F (&OPTIONAL (X 1))
-                 X
-                 #'F
-                 (F X)))
-          (F X)
-          #'F))
-      (0 2 2))
-     ((3 2) (0 2 2) (0 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (FLET ((F ()
-               ))
-        (FLET ((F (&OPTIONAL (X 1))
-                 X
-                 #'F
-                 (F X)))
-          (F X)
-          #'F))
-      (1 2 2))
-     ((1 2 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (FLET ((F ()
-               ))
-        (FLET ((F (&OPTIONAL (X 1))
-                 X
-                 #'F
-                 (F X)))
-          (F X)
-          #'F))
-      (1 2 2))
-     ((1 2 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (FLET ((F ()
-               ))
-        (FLET ((F (&OPTIONAL (X 1))
-                 X
-                 #'F
-                 (F X)))
-          (F X)
-          #'F))
-      (3 2))
-     ((3 2) (0 2 2) (0 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F ()
-                 (F)))
-        (LABELS ((F (&OPTIONAL (X 1))
-                   X
-                   (F X)))
-          #'F))
-      (0 0 1))
-     ((0 2 0 1) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F ()
-                 (F)))
-        (LABELS ((F (&OPTIONAL (X 1))
-                   X
-                   (F X)))
-          #'F))
-      (0 2 0 1))
-     ((0 2 0 1) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F ()
-                 (F)))
-        (LABELS ((F (&OPTIONAL (X 1))
-                   X
-                   (F X)))
-          #'F))
-      (0 0 1 2))
-     ((2 2) (0 3 0 1 2) (0 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F ()
-                 (F)))
-        (LABELS ((F (&OPTIONAL (X 1))
-                   X
-                   (F X)))
-          #'F))
-      (0 1 1 0 1 2))
-     ((1 3 0 1 2) (2 0 1 2) (0 1 1 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F ()
-                 (F)))
-        (LABELS ((F (&OPTIONAL (X 1))
-                   X
-                   (F X)))
-          #'F))
-      (2 0 1 2))
-     ((1 3 0 1 2) (2 0 1 2) (0 1 1 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F ()
-                 (F)))
-        (LABELS ((F (&OPTIONAL (X 1))
-                   X
-                   (F X)))
-          #'F))
-      (0 3 0 1 2))
-     ((2 2) (0 3 0 1 2) (0 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F ()
-                 (F)))
-        (LABELS ((F (&OPTIONAL (X 1))
-                   X
-                   (F X)))
-          #'F))
-      (1 3 0 1 2))
-     ((1 3 0 1 2) (2 0 1 2) (0 1 1 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F ()
-                 (F)))
-        (LABELS ((F (&OPTIONAL (X 1))
-                   X
-                   (F X)))
-          #'F))
-      (2 2))
-     ((2 2) (0 3 0 1 2) (0 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F (X &KEY (Y X))
-                 (G X))
-               (G (Y)
-                 (F Y)))
-        (G 10))
-      (0 0 1))
-     ((0 2 1 1) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F (X &KEY (Y X))
-                 (G X))
-               (G (Y)
-                 (F Y)))
-        (G 10))
-      (0 1 0 1))
-     ((1 2 0 1) (1 2 1 0 1) (0 1 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F (X &KEY (Y X))
-                 (G X))
-               (G (Y)
-                 (F Y)))
-        (G 10))
-      (0 2 1 0 1))
-     ((0 2 1 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F (X &KEY (Y X))
-                 (G X))
-               (G (Y)
-                 (F Y)))
-        (G 10))
-      (1 2 1 0 1))
-     ((1 2 0 1) (1 2 1 0 1) (0 1 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F (X &KEY (Y X))
-                 (G X))
-               (G (Y)
-                 (F Y)))
-        (G 10))
-      (0 2 0 1))
-     ((0 2) (0 1 1) (0 2 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F (X &KEY (Y X))
-                 (G X))
-               (G (Y)
-                 (F Y)))
-        (G 10))
-      (1 2 0 1))
-     ((1 2 0 1) (1 2 1 0 1) (0 1 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F (X &KEY (Y X))
-                 (G X))
-               (G (Y)
-                 (F Y)))
-        (G 10))
-      (0 1 1))
-     ((0 2) (0 1 1) (0 2 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F (X &KEY (Y X))
-                 (G X))
-               (G (Y)
-                 (F Y)))
-        (G 10))
-      (0 1 1 1))
-     ((1 2 1 1) (0 1 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F (X &KEY (Y X))
-                 (G X))
-               (G (Y)
-                 (F Y)))
-        (G 10))
-      (0 2 1 1))
-     ((0 2 1 1) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F (X &KEY (Y X))
-                 (G X))
-               (G (Y)
-                 (F Y)))
-        (G 10))
-      (1 2 1 1))
-     ((1 2 1 1) (0 1 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F (X &KEY (Y X))
-                 (G X))
-               (G (Y)
-                 (F Y)))
-        (G 10))
-      (0 2))
-     ((0 2) (0 1 1) (0 2 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0))
-        (DO ((X 1 (1+ X)))
-            ((= 10 X))
-          A
-          (LET ((A 1))
-            A)
-          B
-          C))
-      (0 0 1))
-     ((3 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0))
-        (DO ((X 1 (1+ X)))
-            ((= 10 X))
-          A
-          (LET ((A 1))
-            A)
-          B
-          C))
-      (0 0 1 2))
-     NIL)
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0))
-        (DO ((X 1 (1+ X)))
-            ((= 10 X))
-          A
-          (LET ((A 1))
-            A)
-          B
-          C))
-      (3 2))
-     ((3 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0))
-        (DO ((X 1 (1+ X)))
-            ((= 10 X))
-          A
-          (LET ((A 1))
-            A)
-          B
-          C))
-      (0 1 4 2))
-     NIL)
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0))
-        (DO ((X 1 (1+ X)))
-            ((= 10 X))
-          A
-          (LET ((A 1))
-            A)
-          B
-          C))
-      (0 0 1 4 2))
-     ((2 4 2) (0 0 1 4 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0))
-        (DO ((X 1 (1+ X)))
-            ((= 10 X))
-          A
-          (LET ((A 1))
-            A)
-          B
-          C))
-      (2 4 2))
-     ((2 4 2) (0 0 1 4 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0))
-        (DO ((X 1 (1+ X)))
-            ((= 10 X))
-          A
-          (LET ((A 1))
-            A)
-          B
-          C))
-      (5 2))
-     ((5 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0))
-        (DO ((X 1 (1+ X)))
-            ((= 10 X))
-          A
-          (LET ((A 1))
-            A)
-          B
-          C))
-      (6 2))
-     ((6 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0))
-        (WITH-HOGE NIL A B C))
-      (0 0 1))
-     ((2 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE)
-        (LET ((A 0))
-          A))
-      (0 0 1 2))
-     ((2 2) (0 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE)
-        (LET ((A 0))
-          A))
-      (2 2))
-     ((2 2) (0 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (BLOCK FOO
-        (RETURN-FROM FOO 10)
-        (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
-        (RETURN-FROM FOO 40))
-      (1))
-     ((1 4) (1 2) (1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE)
-        (LET ((A 0))
-          A))
-      (2 2))
-     ((2 2) (0 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE)
-        (LET ((A 0))
-          A))
-      (0 0 1 2))
-     ((2 2) (0 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0))
-        (WITH-HOGE NIL A B C))
-      (0 0 1))
-     ((2 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0))
-        (DO ((X 1 (1+ X)))
-            ((= 10 X))
-          A
-          (LET ((A 1))
-            A)
-          B
-          C))
-      (6 2))
-     ((6 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0))
-        (DO ((X 1 (1+ X)))
-            ((= 10 X))
-          A
-          (LET ((A 1))
-            A)
-          B
-          C))
-      (5 2))
-     ((5 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0))
-        (DO ((X 1 (1+ X)))
-            ((= 10 X))
-          A
-          (LET ((A 1))
-            A)
-          B
-          C))
-      (2 4 2))
-     ((2 4 2) (0 0 1 4 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0))
-        (DO ((X 1 (1+ X)))
-            ((= 10 X))
-          A
-          (LET ((A 1))
-            A)
-          B
-          C))
-      (0 0 1 4 2))
-     ((2 4 2) (0 0 1 4 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0))
-        (DO ((X 1 (1+ X)))
-            ((= 10 X))
-          A
-          (LET ((A 1))
-            A)
-          B
-          C))
-      (0 1 4 2))
-     NIL)
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0))
-        (DO ((X 1 (1+ X)))
-            ((= 10 X))
-          A
-          (LET ((A 1))
-            A)
-          B
-          C))
-      (3 2))
-     ((3 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0))
-        (DO ((X 1 (1+ X)))
-            ((= 10 X))
-          A
-          (LET ((A 1))
-            A)
-          B
-          C))
-      (0 0 1 2))
-     NIL)
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0))
-        (DO ((X 1 (1+ X)))
-            ((= 10 X))
-          A
-          (LET ((A 1))
-            A)
-          B
-          C))
-      (0 0 1))
-     ((3 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F (X &KEY (Y X))
-                 (G X))
-               (G (Y)
-                 (F Y)))
-        (G 10))
-      (0 2))
-     ((0 2) (0 1 1) (0 2 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F (X &KEY (Y X))
-                 (G X))
-               (G (Y)
-                 (F Y)))
-        (G 10))
-      (1 2 1 1))
-     ((1 2 1 1) (0 1 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F (X &KEY (Y X))
-                 (G X))
-               (G (Y)
-                 (F Y)))
-        (G 10))
-      (0 2 1 1))
-     ((0 2 1 1) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F (X &KEY (Y X))
-                 (G X))
-               (G (Y)
-                 (F Y)))
-        (G 10))
-      (0 1 1 1))
-     ((1 2 1 1) (0 1 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F (X &KEY (Y X))
-                 (G X))
-               (G (Y)
-                 (F Y)))
-        (G 10))
-      (0 1 1))
-     ((0 2) (0 1 1) (0 2 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F (X &KEY (Y X))
-                 (G X))
-               (G (Y)
-                 (F Y)))
-        (G 10))
-      (1 2 0 1))
-     ((1 2 0 1) (1 2 1 0 1) (0 1 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F (X &KEY (Y X))
-                 (G X))
-               (G (Y)
-                 (F Y)))
-        (G 10))
-      (0 2 0 1))
-     ((0 2) (0 1 1) (0 2 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F (X &KEY (Y X))
-                 (G X))
-               (G (Y)
-                 (F Y)))
-        (G 10))
-      (1 2 1 0 1))
-     ((1 2 0 1) (1 2 1 0 1) (0 1 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F (X &KEY (Y X))
-                 (G X))
-               (G (Y)
-                 (F Y)))
-        (G 10))
-      (0 2 1 0 1))
-     ((0 2 1 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F (X &KEY (Y X))
-                 (G X))
-               (G (Y)
-                 (F Y)))
-        (G 10))
-      (0 1 0 1))
-     ((1 2 0 1) (1 2 1 0 1) (0 1 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F (X &KEY (Y X))
-                 (G X))
-               (G (Y)
-                 (F Y)))
-        (G 10))
-      (0 0 1))
-     ((0 2 1 1) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F ()
-                 (F)))
-        (LABELS ((F (&OPTIONAL (X 1))
-                   X
-                   (F X)))
-          #'F))
-      (2 2))
-     ((2 2) (0 3 0 1 2) (0 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F ()
-                 (F)))
-        (LABELS ((F (&OPTIONAL (X 1))
-                   X
-                   (F X)))
-          #'F))
-      (1 3 0 1 2))
-     ((1 3 0 1 2) (2 0 1 2) (0 1 1 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F ()
-                 (F)))
-        (LABELS ((F (&OPTIONAL (X 1))
-                   X
-                   (F X)))
-          #'F))
-      (0 3 0 1 2))
-     ((2 2) (0 3 0 1 2) (0 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F ()
-                 (F)))
-        (LABELS ((F (&OPTIONAL (X 1))
-                   X
-                   (F X)))
-          #'F))
-      (2 0 1 2))
-     ((1 3 0 1 2) (2 0 1 2) (0 1 1 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F ()
-                 (F)))
-        (LABELS ((F (&OPTIONAL (X 1))
-                   X
-                   (F X)))
-          #'F))
-      (0 1 1 0 1 2))
-     ((1 3 0 1 2) (2 0 1 2) (0 1 1 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F ()
-                 (F)))
-        (LABELS ((F (&OPTIONAL (X 1))
-                   X
-                   (F X)))
-          #'F))
-      (0 0 1 2))
-     ((2 2) (0 3 0 1 2) (0 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F ()
-                 (F)))
-        (LABELS ((F (&OPTIONAL (X 1))
-                   X
-                   (F X)))
-          #'F))
-      (0 2 0 1))
-     ((0 2 0 1) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LABELS ((F ()
-                 (F)))
-        (LABELS ((F (&OPTIONAL (X 1))
-                   X
-                   (F X)))
-          #'F))
-      (0 0 1))
-     ((0 2 0 1) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (FLET ((F ()
-               ))
-        (FLET ((F (&OPTIONAL (X 1))
-                 X
-                 #'F
-                 (F X)))
-          (F X)
-          #'F))
-      (3 2))
-     ((3 2) (0 2 2) (0 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (FLET ((F ()
-               ))
-        (FLET ((F (&OPTIONAL (X 1))
-                 X
-                 #'F
-                 (F X)))
-          (F X)
-          #'F))
-      (1 2 2))
-     ((1 2 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (FLET ((F ()
-               ))
-        (FLET ((F (&OPTIONAL (X 1))
-                 X
-                 #'F
-                 (F X)))
-          (F X)
-          #'F))
-      (1 2 2))
-     ((1 2 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (FLET ((F ()
-               ))
-        (FLET ((F (&OPTIONAL (X 1))
-                 X
-                 #'F
-                 (F X)))
-          (F X)
-          #'F))
-      (0 2 2))
-     ((3 2) (0 2 2) (0 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (FLET ((F ()
-               ))
-        (FLET ((F (&OPTIONAL (X 1))
-                 X
-                 #'F
-                 (F X)))
-          (F X)
-          #'F))
-      (1 4 0 1 2))
-     ((1 4 0 1 2) (2 0 1 2) (0 1 1 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (FLET ((F ()
-               ))
-        (FLET ((F (&OPTIONAL (X 1))
-                 X
-                 #'F
-                 (F X)))
-          (F X)
-          #'F))
-      (0 4 0 1 2))
-     ((0 4 0 1 2) (3 0 1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (FLET ((F ()
-               ))
-        (FLET ((F (&OPTIONAL (X 1))
-                 X
-                 #'F
-                 (F X)))
-          (F X)
-          #'F))
-      (3 0 1 2))
-     ((0 4 0 1 2) (3 0 1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (FLET ((F ()
-               ))
-        (FLET ((F (&OPTIONAL (X 1))
-                 X
-                 #'F
-                 (F X)))
-          (F X)
-          #'F))
-      (4 0 1 2))
-     NIL)
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (FLET ((F ()
-               ))
-        (FLET ((F (&OPTIONAL (X 1))
-                 X
-                 #'F
-                 (F X)))
-          (F X)
-          #'F))
-      (2 0 1 2))
-     ((1 4 0 1 2) (2 0 1 2) (0 1 1 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (FLET ((F ()
-               ))
-        (FLET ((F (&OPTIONAL (X 1))
-                 X
-                 #'F
-                 (F X)))
-          (F X)
-          #'F))
-      (0 1 1 0 1 2))
-     ((1 4 0 1 2) (2 0 1 2) (0 1 1 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (FLET ((F ()
-               ))
-        (FLET ((F (&OPTIONAL (X 1))
-                 X
-                 #'F
-                 (F X)))
-          (F X)
-          #'F))
-      (0 0 1 2))
-     ((3 2) (0 2 2) (0 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (FLET ((F ()
-               ))
-        (FLET ((F (&OPTIONAL (X 1))
-                 X
-                 #'F
-                 (F X)))
-          (F X)
-          #'F))
-      (1 1 2))
-     NIL)
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (FLET ((F ()
-               ))
-        (FLET ((F (&OPTIONAL (X 1))
-                 X
-                 #'F
-                 (F X)))
-          (F X)
-          #'F))
-      (0 0 1))
-     ((0 4 0 1 2) (3 0 1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (5 1))
-     ((5 1) (0 8 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (4 1))
-     ((4 1) (6 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (3 1))
-     ((3 1) (0 5 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (2 1))
-     ((2 1) (1 5 1 1) (0 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
-      (0 8 1 1))
-     ((5 1) (0 8 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
-      (6 1 1))
-     ((4 1) (6 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
-      (1 5 1 1))
-     ((2 1) (1 5 1 1) (0 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
-      (0 5 1 1))
-     ((3 1) (0 5 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
-      (3 1 1))
-     ((3 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
-      (2 1 1))
-     ((2 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
-      (1 1 1))
-     ((1 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS #'(LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO)
-      (0 1 1))
-     ((2 1) (1 5 1 1) (0 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (5))
-     ((5) (0 8 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (4))
-     ((4) (6 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (3))
-     ((3) (0 5 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (2))
-     ((2) (1 5 1) (0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (0 8 1))
-     ((5) (0 8 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (6 1))
-     ((4) (6 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (1 5 1))
-     ((2) (1 5 1) (0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (0 5 1))
-     ((3) (0 5 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (3 1))
-     ((3 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (2 1))
-     ((2 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (1 1))
-     ((1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LAMBDA (X A B C &KEY (Y X) Z &AUX (FOO 10)) X Y Z FOO) (0 1))
-     ((2) (1 5 1) (0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (3 7))
-     ((3 7)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (2 2 7))
-     ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (1 7))
-     ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (3 6))
-     ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (2 6))
-     ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (1 6))
-     ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (2 5))
-     ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (1 5))
-     ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (4 4))
-     ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (3 4))
-     ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (2 4))
-     ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (1 4))
-     ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (4 3))
-     ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (3 3))
-     ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (2 3))
-     ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (2 2))
-     ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (2 2))
-     ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (1 2))
-     ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (0 1 1))
-     ((2 2 7) (2 6) (2 5) (3 4) (2 4) (3 3) (2 2) (0 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 0) (B 1))
-        (LOAD-TIME-VALUE A B)
-        (MULTIPLE-VALUE-CALL 'F A B A)
-        (SETQ A B
-              B A)
-        (PROGN A B)
-        (MULTIPLE-VALUE-PROG1 A B A)
-        (UNWIND-PROTECT A (THE INTEGER B) C))
-      (0 0 1))
-     ((1 7) (3 6) (1 6) (1 5) (4 4) (1 4) (4 3) (2 3) (1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 1))
-        (LET ((B A))
-          A
-          B))
-      (3 2))
-     ((3 2) (0 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 1))
-        (LET ((B A))
-          A
-          B))
-      (2 2))
-     ((2 2) (1 0 1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 1))
-        (LET ((B A))
-          A
-          B))
-      (1 0 1 2))
-     ((2 2) (1 0 1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 1))
-        (LET ((B A))
-          A
-          B))
-      (0 0 1 2))
-     ((3 2) (0 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((A 1))
-        (LET ((B A))
-          A
-          B))
-      (0 0 1))
-     ((2 2) (1 0 1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET* ((A 0) (B A))
-        (LET* ((A A) (B A))
-          A)
-        A)
-      (3))
-     ((3) (1 0 1 2) (1 1 1) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET* ((A 0) (B A))
-        (LET* ((A A) (B A))
-          A)
-        A)
-      (2 2))
-     ((2 2) (1 1 1 2) (0 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET* ((A 0) (B A))
-        (LET* ((A A) (B A))
-          A)
-        A)
-      (1 1 1 2))
-     ((2 2) (1 1 1 2) (0 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET* ((A 0) (B A))
-        (LET* ((A A) (B A))
-          A)
-        A)
-      (0 1 1 2))
-     ((0 1 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET* ((A 0) (B A))
-        (LET* ((A A) (B A))
-          A)
-        A)
-      (1 0 1 2))
-     ((3) (1 0 1 2) (1 1 1) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET* ((A 0) (B A))
-        (LET* ((A A) (B A))
-          A)
-        A)
-      (0 0 1 2))
-     ((2 2) (1 1 1 2) (0 0 1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET* ((A 0) (B A))
-        (LET* ((A A) (B A))
-          A)
-        A)
-      (1 1 1))
-     ((3) (1 0 1 2) (1 1 1) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET* ((A 0) (B A))
-        (LET* ((A A) (B A))
-          A)
-        A)
-      (0 1 1))
-     ((0 1 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET* ((A 0) (B A))
-        (LET* ((A A) (B A))
-          A)
-        A)
-      (0 0 1))
-     ((3) (1 0 1 2) (1 1 1) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (BLOCK FOO
-        (RETURN-FROM FOO 10)
-        (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
-        (RETURN-FROM FOO 40))
-      (1 4))
-     ((1 4) (1 2) (1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (BLOCK FOO
-        (RETURN-FROM FOO 10)
-        (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
-        (RETURN-FROM FOO 40))
-      (1 3 3))
-     ((1 3 3) (1 2 3) (1 3)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (BLOCK FOO
-        (RETURN-FROM FOO 10)
-        (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
-        (RETURN-FROM FOO 40))
-      (1 2 3))
-     ((1 3 3) (1 2 3) (1 3)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (BLOCK FOO
-        (RETURN-FROM FOO 10)
-        (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
-        (RETURN-FROM FOO 40))
-      (1 3))
-     ((1 3 3) (1 2 3) (1 3)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (BLOCK FOO
-        (RETURN-FROM FOO 10)
-        (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
-        (RETURN-FROM FOO 40))
-      (1 2))
-     ((1 4) (1 2) (1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (BLOCK FOO
-        (RETURN-FROM FOO 10)
-        (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
-        (RETURN-FROM FOO 40))
-      (1))
-     ((1 4) (1 2) (1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS FOO NIL) NIL)
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS FOO NIL) NIL)
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS FOO NIL) NIL)
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (BLOCK FOO
-        (RETURN-FROM FOO 10)
-        (BLOCK FOO (RETURN-FROM FOO 20) (RETURN-FROM FOO 30))
-        (RETURN-FROM FOO 40))
-      (1))
-     ((1 4) (1 2) (1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFUN F (X Y) X Y X Y) (6)) ((6) (4) (1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFUN F (X Y) X Y X Y) (5)) ((5) (3) (0 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFUN F (X Y) X Y X Y) (4)) ((6) (4) (1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFUN F (X Y) X Y X Y) (3)) ((5) (3) (0 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFUN F (X Y) X Y X Y) (1 2)) ((6) (4) (1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFUN F (X Y) X Y X Y) (0 2)) ((5) (3) (0 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFMETHOD ADD (X Y) (+ X Y)) (2 3)) ((2 3) (1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFMETHOD ADD (X Y) (+ X Y)) (1 3)) ((1 3) (0 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFMETHOD ADD (X Y) (+ X Y)) (1 2)) ((2 3) (1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFMETHOD ADD (X Y) (+ X Y)) (0 2)) ((1 3) (0 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (DEFMETHOD MICROS/WALKER::ADD (MICROS/WALKER::X MICROS/WALKER::Y) (+ MICROS/WALKER::X MICROS/WALKER::Y))
-      (2 3))
-     ((2 3) (1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (DEFMETHOD MICROS/WALKER::ADD (MICROS/WALKER::X MICROS/WALKER::Y) (+ MICROS/WALKER::X MICROS/WALKER::Y))
-      (1 3))
-     ((1 3) (0 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (DEFMETHOD MICROS/WALKER::ADD (MICROS/WALKER::X MICROS/WALKER::Y) (+ MICROS/WALKER::X MICROS/WALKER::Y))
-      (1 2))
-     ((2 3) (1 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (DEFMETHOD MICROS/WALKER::ADD (MICROS/WALKER::X MICROS/WALKER::Y) (+ MICROS/WALKER::X MICROS/WALKER::Y))
-      (0 2))
-     ((1 3) (0 2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFMETHOD ADD :BEFORE ((X INTEGER) (Y INTEGER)) (PRINT (LIST X Y)))
-      (2 1 4))
-     ((2 1 4) (0 1 3)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFMETHOD ADD :BEFORE ((X INTEGER) (Y INTEGER)) (PRINT (LIST X Y)))
-      (1 1 4))
-     ((1 1 4) (0 0 3)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFMETHOD ADD :BEFORE ((X INTEGER) (Y INTEGER)) (PRINT (LIST X Y)))
-      (0 1 3))
-     ((2 1 4) (0 1 3)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (DEFMETHOD ADD :BEFORE ((X INTEGER) (Y INTEGER)) (PRINT (LIST X Y)))
-      (0 0 3))
-     ((1 1 4) (0 0 3)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      ((LAMBDA (MICROS/WALKER::A MICROS/WALKER::B) (+ MICROS/WALKER::A MICROS/WALKER::B)) 1 2) (2 2 0))
-     ((2 2 0) (1 1 0)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      ((LAMBDA (MICROS/WALKER::A MICROS/WALKER::B) (+ MICROS/WALKER::A MICROS/WALKER::B)) 1 2) (1 2 0))
-     ((1 2 0) (0 1 0)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      ((LAMBDA (MICROS/WALKER::A MICROS/WALKER::B) (+ MICROS/WALKER::A MICROS/WALKER::B)) 1 2) (1 1 0))
-     ((2 2 0) (1 1 0)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      ((LAMBDA (MICROS/WALKER::A MICROS/WALKER::B) (+ MICROS/WALKER::A MICROS/WALKER::B)) 1 2)
-      (0 1 0))
-     ((1 2 0) (0 1 0)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((COMMON-LISP-USER::A 0))
-        COMMON-LISP-USER::A
-        ((LAMBDA (COMMON-LISP-USER::A) (DECLARE (SPECIAL COMMON-LISP-USER::A)) COMMON-LISP-USER::A))
-        ((LAMBDA (COMMON-LISP-USER::A) (DECLARE (SPECIAL COMMON-LISP-USER::A)) COMMON-LISP-USER::A))
-        COMMON-LISP-USER::A)
-      (3 0 3))
-     ((3 0 4) (0 1 0 4) (3 0 3) (0 1 0 3)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((X 0))
-        (LOOP (F X)))
-      (1 1 2))
-     ((1 1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LET ((X 0))
-        (LOOP (F X)))
-      (0 0 1))
-     ((1 1 2) (0 0 1)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LOOP :WITH X := 0
-            :WITH Y := X
-            :WITH Z := (F X Y))
-      (2 12))
-     ((6) (2 12)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LOOP :WITH X := 0
-            :WITH Y := X
-            :WITH Z := (F X Y))
-      (1 12))
-     ((2) (8) (1 12)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LOOP :WITH X := 0
-            :WITH Y := X
-            :WITH Z := (F X Y))
-      (8))
-     ((2) (8) (1 12)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LOOP :WITH X := 0
-            :WITH Y := X
-            :WITH Z := (F X Y))
-      (10))
-     ((10)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LOOP :WITH X := 0
-            :WITH Y := X
-            :WITH Z := (F X Y))
-      (6))
-     ((6) (2 12)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LOOP :WITH X := 0
-            :WITH Y := X
-            :WITH Z := (F X Y))
-      (2))
-     ((2) (8) (1 12)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LOOP :WITH X := 0
-            :DO (F X))
-      (1 6))
-     ((1 6) (2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LOOP :WITH X := 0
-            :DO (F X))
-      (2))
-     ((1 6) (2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LOOP :WITH X := 0 :RETURN :IT :RETURN (F X)) (6))
-     NIL)
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LOOP :WITH X := 0 :RETURN :IT :RETURN (F X)) (1 8))
-     ((1 8) (2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS (LOOP :WITH X := 0 :RETURN :IT :RETURN (F X)) (2))
-     ((1 8) (2)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LOOP :WITH ((X Y) . Z) := (F)
-            :WITH A := (+ X Y Z))
-      (3 8))
-     ((2 2) (3 8)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LOOP :WITH ((X Y) . Z) := (F)
-            :WITH A := (+ X Y Z))
-      (2 8))
-     ((1 0 2) (2 8)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LOOP :WITH ((X Y) . Z) := (F)
-            :WITH A := (+ X Y Z))
-      (1 8))
-     ((0 0 2) (1 8)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LOOP :WITH ((X Y) . Z) := (F)
-            :WITH A := (+ X Y Z))
-      (2 2))
-     ((2 2) (3 8)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LOOP :WITH ((X Y) . Z) := (F)
-            :WITH A := (+ X Y Z))
-      (1 0 2))
-     ((1 0 2) (2 8)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LOOP :WITH ((X Y) . Z) := (F)
-            :WITH A := (+ X Y Z))
-      (0 0 2))
-     ((0 0 2) (1 8)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LOOP :WITH (X . Y) := (F)
-            :WITH A := X
-            :WITH B := Y)
-      (12))
-     ((2 2) (12)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LOOP :WITH (X . Y) := (F)
-            :WITH A := X
-            :WITH B := Y)
-      (8))
-     ((0 2) (8)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LOOP :WITH (X . Y) := (F)
-            :WITH A := X
-            :WITH B := Y)
-      (2 2))
-     ((2 2) (12)))
-    ((MICROS/WALKER:COLLECT-HIGHLIGHT-PATHS
-      (LOOP :WITH (X . Y) := (F)
-            :WITH A := X
-            :WITH B := Y)
-      (0 2))
-     ((0 2) (8)))))
+(defun load-test-cases ()
+  (uiop:read-file-forms (asdf:system-relative-pathname :micros/tests "contrib/walker/tests/test-cases.lisp")))
 
 (deftest random
-  (loop :for (act-form expected) :in *test-cases*
+  (loop :for (act-form expected) :in (load-test-cases)
         :for n :from 0
         :do (ok (equal expected (apply (first act-form) (rest act-form)))
                 (format nil "~D ~S" n act-form))))
diff --git a/contrib/walker/walker.lisp b/contrib/walker/walker.lisp
index 3887758..3d7e36b 100644
--- a/contrib/walker/walker.lisp
+++ b/contrib/walker/walker.lisp
@@ -961,7 +961,7 @@
   (call-next-method))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(defparameter *record-test-cases* nil)
+(defparameter *record-test-cases* t)
 (defvar *test-cases* '())
 
 (defun collect-highlight-paths (form path)