anchor.diff:           appending (list key (getf named-params key)))))
   
   (defun hash-keys (hash)
  -  "Returns a list of all the keys in the given hash table."
  +  "Returns a list of all the keys in HASH, which is a hash table."
     (loop for a being the hash-keys in hash collect a))
   
   (defun hash-values (hash)
  -  "Returns a list of all the values in the given hash table."
  +  "Returns a list of all the values in HASH, which is a hash table."
     (loop for a being the hash-values in hash collect a))
   
   (defun interruptible-sleep (secs name)
  -  "Sets up a named timer and sleeps for secs seconds or until another thread calls the interrupt-sleep function with the given name.  This function checks once per second to see if the timer has been reached or interrupted."
  +  "Sets up a named timer and sleeps for SECS seconds or until another thread calls the interrupt-sleep function with NAME.  This function checks once per second to see if the timer has been reached or interrupted."
     (let ((target (+ (get-universal-time) secs)))
       (setf (gethash name *interruptible-sleep-hash*) nil)
       (loop while (and (< (get-universal-time) target)
  
positive.code:           :seconds seconds :hours hours :days days)))
  
  (defun thread-pool-time-to-go (pool-name total-record-count)
    "Returns the amount of time left for the given pool to complete processing all the records."
    (time-to-go
     (change-per-second (lambda () (thread-pool-progress pool-name)) 10)
     (- total-record-count (thread-pool-progress pool-name))))
  
  (defun thread-pool-start-time (pool-name)
    "Retrieves the start-time for the given thread-pool."
    (getf *dc-thread-pool-start-time* pool-name))
  
  (defun thread-pool-stop-time (pool-name)
    "Retrieves the stop-time for the given thread-pool."
    (getf *dc-thread-pool-stop-time* pool-name))
  
  (defun thread-pool-run-time (pool-name)
    "Computes the number of seconds that the given thread-pool has been running."
    (let ((start (thread-pool-start-time pool-name))
          (stop (thread-pool-stop-time pool-name)))
      (if start (- (if stop stop (get-universal-time)) start) 0)))
  
  (defun thread-pool-progress (pool-name)
    "Retrieves the count of the records that the given thread pool has already processed."
    (getf *dc-thread-pool-progress* pool-name))
  
  (defun job-queue (pool-name)
    "Retrieve the job-queue for the given thread pool."
    (getf *dc-job-queue* pool-name))
  
  (defun thread-pool-start
      (pool-name thread-count job-queue fn-job &optional fn-finally)
    "Starts thread-count threads using pool-name to name the threads and runs fn-job with those threads.  Each thread runs fn-job, which takes no parameters, in a loop.  When all the threads are done, this function checks fn-finally.  If the caller provides fn-finally, then this function returns with the result of calling fn-finally.  If the caller doesn't provide fn-finally, then the this function exists with a sum of the return values of all the threads that ran."
    (setf (getf *dc-thread-pool-progress* pool-name) 0)
    (setf (getf *dc-progress-mutex* pool-name)
          (make-mutex :name (symbol-name pool-name)))
  
negative.code:            (when ,transformed-line (write-line ,transformed-line ,output)))))))
  
  (defun freeze (object)
    "Serializes OBJECT into a string, returning the string."
    (with-output-to-string (s) (write object :stream s :readably t)))
  
  (defun thaw (string)
    "Deserializes an object (or data structure) from the string expression in STRING, returning the object."
    (with-input-from-string (s string) (read s)))
  
  (defun slurp (filename)
    "Reads the entire file FILENAME into a string and returns the string."
    (with-open-file (stream filename)
      (let ((seq (make-array (file-length stream)
                             :element-type 'character :fill-pointer t)))
  