 (defn lookup'' [keys table]
   (loop [keys keys
          table table]
-    (let [subtable (assok (first keys) (cdr table))]
-      (if subtable
-        (if (empty? (rest keys))
-          (cdr subtable)
-          (recur (rest keys) subtable))
-        false))))
+    (if-let [subtable (assok (first keys) (cdr table))]
+      (if (empty? (rest keys))
+        (cdr subtable)
+        (recur (rest keys) subtable))
+      false)))
 
 ;; FIXME
 (defn insert!'' [keys value table]
   (loop [keys keys
          table table]
-    (let [subtable (assok (first keys) (cdr table))]
-      (if subtable
-        (if (empty? (rest keys))
-          (set-cdr! subtable value)
-          (recur (rest keys) subtable))
-        (set-cdr! table
-                  (let [rkeys (reverse keys)]
-                    (kons (reduce #(scheme-like-list %2 %1)
-                                  (kons (first rkeys) value)
-                                  (rest rkeys))
-                          (cdr table)))))))
+    (if-let [subtable (assok (first keys) (cdr table))]
+      (if (empty? (rest keys))
+        (set-cdr! subtable value)
+        (recur (rest keys) subtable))
+      (set-cdr! table
+                (let [rkeys (reverse keys)]
+                  (kons (reduce #(scheme-like-list %2 %1)
+                                (kons (first rkeys) value)
+                                (rest rkeys))
+                        (cdr table))))))
   :ok)
 
 ;;; 3.3.4  A Simulator for Digital Circuits

    :else (recur key (cdr records))))

(defn lookup [key table]
  (let [record (assok key (cdr table))]
    (if record
      (cdr record)
      false)))

(defn insert! [key value table]
  (let [record (assok key (cdr table))]
    (if record
      (set-cdr! record value)
      (set-cdr! table
                (kons (kons key value) (cdr table)))))
  :ok)

(defn make-table []
  (scheme-like-list '*table*))

(defn lookup' [key-1 key-2 table]
  (let [subtable (assok key-1 (cdr table))]
    (if subtable
      (let [record (assok key-2 (cdr subtable))]
        (if record
          (cdr record)
          false))
      false)))

(defn insert!' [key-1 key-2 value table]
  (let [subtable (assok key-1 (cdr table))]
    (if subtable
      (let [record (assok key-2 (cdr subtable))]
        (if record
          (set-cdr! record value)
          (set-cdr! subtable
                    (kons (kons key-2 value)
                          (cdr subtable)))))
      (set-cdr! table
                (kons (scheme-like-list key-1
                                        (kons key-2 value))
                      (cdr table)))))
  :ok)

(defn make-table' []
  (let [local-table (scheme-like-list '*table*)
        lookup (fn [key-1 key-2]
                 (let [subtable (assok key-1 (cdr local-table))]
                   (if subtable
                     (let [record (assok key-2 (cdr subtable))]
                       (if record
                         (cdr record)
                         false))
                     false)))
        insert! (fn [key-1 key-2 value]
                  (let [subtable (assok key-1 (cdr local-table))]
                    (if subtable
                      (let [record (assok key-2 (cdr subtable))]
                        (if record
                          (set-cdr! record value)
                          (set-cdr! subtable
                                    (kons (kons key-2 value)
                                          (cdr subtable)))))
                      (set-cdr! local-table
                                (kons (scheme-like-list key-1
                                                        (kons key-2 value))
                                      (cdr local-table)))))
                  :ok)
        dispatch (fn [m]
                   (case m

  (let [new-pair (kons item nil)]
    (if (empty-queue? queue)
      (do (set-front-ptr! queue new-pair)
          (set-rear-ptr! queue new-pair))
      (do (set-cdr! (rear-ptr queue) new-pair)
          (set-rear-ptr! queue new-pair)))
    queue))

(defn delete-queue! [queue]
  (if (empty-queue? queue)
